From 15fe7a530d352aecea65f952e6b321635b4fe2a8 Mon Sep 17 00:00:00 2001 From: Reid Kleckner Date: Tue, 15 Jul 2014 01:16:09 +0000 Subject: [PATCH] Document the maximum LLVM IR alignment, which is 1 << 29 or 0.5 GiB Add verifier checks. We already check these in the assembly parser, but a frontend producing IR in memory wouldn't hit those checks. llvm-svn: 213027 --- llvm/docs/LangRef.rst | 14 ++++++++------ llvm/lib/IR/Verifier.cpp | 8 ++++++++ 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst index cc9656a7bfa4..a6276418baf9 100644 --- a/llvm/docs/LangRef.rst +++ b/llvm/docs/LangRef.rst @@ -582,7 +582,7 @@ to over-align the global if the global has an assigned section. In this case, the extra alignment could be observable: for example, code could assume that the globals are densely packed in their section and try to iterate over them as an array, alignment padding would break this -iteration. +iteration. The maximum alignment is ``1 << 29``. Globals can also have a :ref:`DLL storage class `. @@ -4925,9 +4925,10 @@ bytes of memory on the runtime stack, returning a pointer of the appropriate type to the program. If "NumElements" is specified, it is the number of elements allocated, otherwise "NumElements" is defaulted to be one. If a constant alignment is specified, the value result of the -allocation is guaranteed to be aligned to at least that boundary. If not -specified, or if zero, the target can choose to align the allocation on -any convenient boundary compatible with the type. +allocation is guaranteed to be aligned to at least that boundary. The +alignment may not be greater than ``1 << 29``. If not specified, or if +zero, the target can choose to align the allocation on any convenient +boundary compatible with the type. '``type``' may be any sized type. @@ -5001,7 +5002,8 @@ or an omitted ``align`` argument means that the operation has the ABI alignment for the target. It is the responsibility of the code emitter to ensure that the alignment information is correct. Overestimating the alignment results in undefined behavior. Underestimating the alignment -may produce less efficient code. An alignment of 1 is always safe. +may produce less efficient code. An alignment of 1 is always safe. The +maximum possible alignment is ``1 << 29``. The optional ``!nontemporal`` metadata must reference a single metadata name ```` corresponding to a metadata node with one @@ -5087,7 +5089,7 @@ alignment for the target. It is the responsibility of the code emitter to ensure that the alignment information is correct. Overestimating the alignment results in undefined behavior. Underestimating the alignment may produce less efficient code. An alignment of 1 is always -safe. +safe. The maximum possible alignment is ``1 << 29``. The optional ``!nontemporal`` metadata must reference a single metadata name ```` corresponding to a metadata node with one ``i32`` entry of diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp index ec7ae3a77a73..9cf911b51a4b 100644 --- a/llvm/lib/IR/Verifier.cpp +++ b/llvm/lib/IR/Verifier.cpp @@ -380,6 +380,8 @@ void Verifier::visitGlobalValue(const GlobalValue &GV) { "Global is external, but doesn't have external or weak linkage!", &GV); + Assert1(GV.getAlignment() <= Value::MaximumAlignment, + "huge alignment values are unsupported", &GV); Assert1(!GV.hasAppendingLinkage() || isa(GV), "Only global variables can have appending linkage!", &GV); @@ -1891,6 +1893,8 @@ void Verifier::visitLoadInst(LoadInst &LI) { Type *ElTy = PTy->getElementType(); Assert2(ElTy == LI.getType(), "Load result type does not match pointer operand type!", &LI, ElTy); + Assert1(LI.getAlignment() <= Value::MaximumAlignment, + "huge alignment values are unsupported", &LI); if (LI.isAtomic()) { Assert1(LI.getOrdering() != Release && LI.getOrdering() != AcquireRelease, "Load cannot have Release ordering", &LI); @@ -1966,6 +1970,8 @@ void Verifier::visitStoreInst(StoreInst &SI) { Assert2(ElTy == SI.getOperand(0)->getType(), "Stored value type does not match pointer operand type!", &SI, ElTy); + Assert1(SI.getAlignment() <= Value::MaximumAlignment, + "huge alignment values are unsupported", &SI); if (SI.isAtomic()) { Assert1(SI.getOrdering() != Acquire && SI.getOrdering() != AcquireRelease, "Store cannot have Acquire ordering", &SI); @@ -1997,6 +2003,8 @@ void Verifier::visitAllocaInst(AllocaInst &AI) { &AI); Assert1(AI.getArraySize()->getType()->isIntegerTy(), "Alloca array size must have integer type", &AI); + Assert1(AI.getAlignment() <= Value::MaximumAlignment, + "huge alignment values are unsupported", &AI); visitInstruction(AI); }