Verifier: Verify absolute_symbol metadata

[arsenm]

Summary

This is the same as !range except for one edge case.

[JonChesterfield]

Nice! Thank you very much for picking this up

[arsenm]

53acadafdd388e5ecdf060b47766c2b73f185317

llvm/lib/IR/Verifier.cpp

private:
   void visitModuleCommandLines();
   void visitModuleFlags();
   void visitModuleFlag(const MDNode *Op,
                        DenseMap<const MDString *, const MDNode *> &SeenIDs,
                        SmallVectorImpl<const MDNode *> &Requirements);
   void visitModuleFlagCGProfileEntry(const MDOperand &MDO);
   void visitFunction(const Function &F);
   void visitBasicBlock(BasicBlock &BB);
+  void verifyRangeMetadata(const Value &V, const MDNode *Range, Type *Ty,
+                           bool IsAbsoluteSymbol);
   void visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty);
   void visitDereferenceableMetadata(Instruction &I, MDNode *MD);
   void visitProfMetadata(Instruction &I, MDNode *MD);
   void visitCallStackMetadata(MDNode *MD);
   void visitMemProfMetadata(Instruction &I, MDNode *MD);
   void visitCallsiteMetadata(Instruction &I, MDNode *MD);
   void visitDIAssignIDMetadata(Instruction &I, MDNode *MD);
   void visitAnnotationMetadata(MDNode *Annotation);
if (const MDNode *Associated =
         const Value *Stripped = VM->getValue()->stripPointerCastsAndAliases();
         Check(isa<GlobalObject>(Stripped) || isa<Constant>(Stripped),
               "associated metadata must point to a GlobalObject", GO, Stripped);
         Check(Stripped != GO,
               "global values should not associate to themselves", GO,
               Associated);
       }
     }
+
+    // FIXME: Why is getMetadata on GlobalValue protected?
+    if (const MDNode *AbsoluteSymbol =
+            GO->getMetadata(LLVMContext::MD_absolute_symbol)) {
+      verifyRangeMetadata(*GO, AbsoluteSymbol, DL.getIntPtrType(GO->getType()),
+                          true);
+    }
   }
+
   Check(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
         "Only global variables can have appending linkage!", &GV);
 
   if (GV.hasAppendingLinkage()) {
     const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);
     Check(GVar && GVar->getValueType()->isArrayTy(),
           "Only global arrays can have appending linkage!", GVar);
   }
void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
 
   visitInstruction(GEP);
 }
 
 static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
   return A.getUpper() == B.getLower() || A.getLower() == B.getUpper();
 }
 
-void Verifier::visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty) {
-  assert(Range && Range == I.getMetadata(LLVMContext::MD_range) &&
-         "precondition violation");
-
+/// Verify !range and !absolute_symbol metadata. These have the same
+/// restrictions, except !absolute_symbol allows the full set.
+void Verifier::verifyRangeMetadata(const Value &I, const MDNode *Range,
+                                   Type *Ty, bool IsAbsoluteSymbol) {
   unsigned NumOperands = Range->getNumOperands();
   Check(NumOperands % 2 == 0, "Unfinished range!", Range);
   unsigned NumRanges = NumOperands / 2;
   Check(NumRanges >= 1, "It should have at least one range!", Range);
 
   ConstantRange LastRange(1, true); // Dummy initial value
   for (unsigned i = 0; i < NumRanges; ++i) {
     ConstantInt *Low =
for (unsigned i = 0; i < NumRanges; ++i) {
     APInt LowV = Low->getValue();
 
     // ConstantRange asserts if the ranges are the same except for the min/max
     // value. Leave the cases it tolerates for the empty range error below.
     Check(LowV != HighV || LowV.isMaxValue() || LowV.isMinValue(),
           "The upper and lower limits cannot be the same value", &I);
 
     ConstantRange CurRange(LowV, HighV);
-    Check(!CurRange.isEmptySet() && !CurRange.isFullSet(),
+    Check(!CurRange.isEmptySet() && (IsAbsoluteSymbol || !CurRange.isFullSet()),
           "Range must not be empty!", Range);
     if (i != 0) {
       Check(CurRange.intersectWith(LastRange).isEmptySet(),
             "Intervals are overlapping", Range);
       Check(LowV.sgt(LastRange.getLower()), "Intervals are not in order",
             Range);
       Check(!isContiguous(CurRange, LastRange), "Intervals are contiguous",
             Range);
     }
     LastRange = ConstantRange(LowV, HighV);
   }
   if (NumRanges > 2) {
     APInt FirstLow =
         mdconst::dyn_extract<ConstantInt>(Range->getOperand(0))->getValue();
     APInt FirstHigh =
         mdconst::dyn_extract<ConstantInt>(Range->getOperand(1))->getValue();
     ConstantRange FirstRange(FirstLow, FirstHigh);
     Check(FirstRange.intersectWith(LastRange).isEmptySet(),
           "Intervals are overlapping", Range);
     Check(!isContiguous(FirstRange, LastRange), "Intervals are contiguous",
           Range);
   }
 }
 
+void Verifier::visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty) {
+  assert(Range && Range == I.getMetadata(LLVMContext::MD_range) &&
+         "precondition violation");
+  verifyRangeMetadata(I, Range, Ty, false);
+}
+
 void Verifier::checkAtomicMemAccessSize(Type *Ty, const Instruction *I) {
   unsigned Size = DL.getTypeSizeInBits(Ty);
   Check(Size >= 8, "atomic memory access' size must be byte-sized", Ty, I);
   Check(!(Size & (Size - 1)),
         "atomic memory access' operand must have a power-of-two size", Ty, I);
 }
 
 void Verifier::visitLoadInst(LoadInst &LI) {

llvm/test/Assembler/absolute_symbol.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+; CHECK: @simple_range = external global i32, !absolute_symbol [[META0:![0-9]+]]
+@simple_range = external global i32, !absolute_symbol !0
+
+; Unlike !range, this accepts -1, -1
+; CHECK: @full_range = external global i32, !absolute_symbol [[META1:![0-9]+]]
+@full_range = external global i32, !absolute_symbol !1
+
+; CHECK: @multiple_ranges = external global i32, !absolute_symbol [[META2:![0-9]+]]
+@multiple_ranges = external global i32, !absolute_symbol !2
+
+!0 = !{i64 4096, i64 8192}
+!1 = !{i64 -1, i64 -1}
+!2 = !{i64 256, i64 512, i64 1024, i64 4096}
+;.
+; CHECK: [[META0]] = !{i64 4096, i64 8192}
+; CHECK: [[META1]] = !{i64 -1, i64 -1}
+; CHECK: [[META2]] = !{i64 256, i64 512, i64 1024, i64 4096}
+;.

llvm/test/CodeGen/X86/absolute-constant.ll

if.then:                                          ; preds = %entry
   br label %if.end
 
 if.end:                                           ; preds = %entry, %if.then
   ret void
 }
 
 declare void @xf(...)
 
-!0 = !{i32 0, i32 256}
+!0 = !{i64 0, i64 256}

llvm/test/Verifier/absolute_symbol.ll

+; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
+
+target datalayout = "p0:64:64-p1:32:32"
+
+
+@absolute_empty_arguments = external global i32, !absolute_symbol !0
+
+@absolute_one_argument = external global i32, !absolute_symbol !1
+
+@absolute_three_arguments = external global i32, !absolute_symbol !2
+
+
+
+@absolute_one_argument_wrong_width = external global i32, !absolute_symbol !3
+@absolute_two_arguments_wrong_width = external global i32, !absolute_symbol !4
+
+@absolute_two_arguments_one_wrong_width0 = external global i32, !absolute_symbol !5
+@absolute_two_arguments_one_wrong_width1 = external global i32, !absolute_symbol !6
+
+@absolute_zero_zero = external global i32, !absolute_symbol !7
+
+@absolute_equal_other = external global i32, !absolute_symbol !8
+
+@absolute_wrong_width_non0_as = external addrspace(1) global i32, !absolute_symbol !9
+
+; Test other kinds of symbols besides GlobalVariable
+define void @absolute_func_empty_arguments() !absolute_symbol !0 {
+  ret void
+}
+
+@absolute_is_fp = external global i32, !absolute_symbol !10
+@absolute_is_vector = external global i32, !absolute_symbol !11
+@absolute_is_ptr = external global i32, !absolute_symbol !12
+@absolute_is_ptr0 = external global i32, !absolute_symbol !13
+@absolute_is_ptr1 = external global i32, !absolute_symbol !14
+
+@absolute_wrong_order = external global i32, !absolute_symbol !15
+
+; CHECK: It should have at least one range!
+; CHECK-NEXT: !0 = !{}
+; CHECK: It should have at least one range!
+; CHECK-NEXT: !0 = !{}
+!0 = !{}
+
+; CHECK-NEXT: Unfinished range!
+; CHECK-NEXT: !1 = !{i64 128}
+!1 = !{i64 128}
+
+; CHECK-NEXT: Unfinished range!
+; CHECK-NEXT: !2 = !{i64 128, i64 256, i64 512}
+!2 = !{i64 128, i64 256, i64 512}
+
+; CHECK-NEXT: Unfinished range!
+; CHECK-NEXT: !3 = !{i32 256}
+!3 = !{i32 256}
+
+; CHECK-NEXT: Range types must match instruction type!
+; CHECK-NEXT: ptr @absolute_two_arguments_wrong_width
+!4 = !{i32 256, i32 512}
+
+; CHECK-NEXT: Range types must match instruction type!
+; CHECK-NEXT: ptr @absolute_two_arguments_one_wrong_width0
+!5 = !{i32 256, i64 512}
+
+; CHECK-NEXT: Range types must match instruction type!
+; CHECK-NEXT: ptr @absolute_two_arguments_one_wrong_width1
+!6 = !{i64 256, i32 512}
+
+; CHECK-NEXT: Range must not be empty!
+; CHECK-NEXT: !7 = !{i64 0, i64 0}
+!7 = !{i64 0, i64 0}
+
+; CHECK-NEXT: The upper and lower limits cannot be the same value
+; CHECK-NEXT: ptr @absolute_equal_other
+!8 = !{i64 123, i64 123}
+
+; CHECK-NEXT: Range types must match instruction type!
+; CHECK-NEXT: ptr addrspace(1) @absolute_wrong_width_non0_as
+!9 = !{i64 512, i64 256}
+
+; CHECK-NEXT: The lower limit must be an integer!
+!10 = !{float 0.0, float 256.0}
+
+; CHECK-NEXT: The lower limit must be an integer!
+!11 = !{<2 x i64> zeroinitializer, <2 x i64> <i64 256, i64 256>}
+
+; CHECK-NEXT: The lower limit must be an integer!
+!12 = !{ptr null, ptr inttoptr (i64 256 to ptr)}
+
+; CHECK-NEXT: The lower limit must be an integer!
+!13 = !{ptr null, i64 456}
+
+; CHECK-NEXT: The upper limit must be an integer!
+!14 = !{i64 456, ptr inttoptr (i64 512 to ptr)}
+!15 = !{i64 1024, i64 128}
+