Require "target datalayout" to be at the beginning of an IR file.

[efriedma]

Summary

This will allow us to use the datalayout to disambiguate other constructs in IR, like load alignment. Split off from D78403.

[Meinersbur]

LGTM.

I didn't know we had weird header infos in the middle of test files.

llvm/lib/AsmParser/LLParser.cpp

303–313

[suggestion]

while (true) {
  if (Lex.getKind() == lltok::kw_target) {
    if (ParseTargetDefinition())
      return true;
    continue;
  }

  if (Lex.getKind() == lltok::kw_source_filename) {
    if (ParseSourceFileName())
      return true;
    continue;
  } 
  
  return false;
}

llvm/lib/AsmParser/LLParser.h

bool ParseIndexList(SmallVectorImpl<unsigned> &Indices) {
         return TokError("expected index");
       return false;
     }
 
     // Top-Level Entities
     bool ParseTopLevelEntities();
     bool ValidateEndOfModule();
     bool ValidateEndOfIndex();
+    bool ParseTargetDefinitions();
     bool ParseTargetDefinition();
     bool ParseModuleAsm();
     bool ParseSourceFileName();
     bool ParseDepLibs();        // FIXME: Remove in 4.0.
     bool ParseUnnamedType();
     bool ParseNamedType();
     bool ParseDeclare();
     bool ParseDefine();

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::Run() {
   // Prime the lexer.
   Lex.Lex();
 
   if (Context.shouldDiscardValueNames())
     return Error(
         Lex.getLoc(),
         "Can't read textual IR with a Context that discards named Values");
 
+  if (M) {
+    if (ParseTargetDefinitions())
+      return true;
+  }
+
   return ParseTopLevelEntities() || ValidateEndOfModule() ||
          ValidateEndOfIndex();
 }
 
 bool LLParser::parseStandaloneConstantValue(Constant *&C,
                                             const SlotMapping *Slots) {
   restoreParsingState(Slots);
   Lex.Lex();
bool LLParser::ValidateEndOfIndex() {
 
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // Top-Level Entities
 //===----------------------------------------------------------------------===//
 
+bool LLParser::ParseTargetDefinitions() {
+  while (true) {
+    if (Lex.getKind() == lltok::kw_target) {
+      if (ParseTargetDefinition())
+        return true;
+    } else if (Lex.getKind() == lltok::kw_source_filename) {
+      if (ParseSourceFileName())
+        return true;
+    } else {
+      return false;
+    }
+  }
+}
+
 bool LLParser::ParseTopLevelEntities() {
   // If there is no Module, then parse just the summary index entries.
   if (!M) {
     while (true) {
       switch (Lex.getKind()) {
       case lltok::Eof:
         return false;
       case lltok::SummaryID:
bool LLParser::ParseTopLevelEntities() {
   }
   while (true) {
     switch (Lex.getKind()) {
     default:         return TokError("expected top-level entity");
     case lltok::Eof: return false;
     case lltok::kw_declare: if (ParseDeclare()) return true; break;
     case lltok::kw_define:  if (ParseDefine()) return true; break;
     case lltok::kw_module:  if (ParseModuleAsm()) return true; break;
-    case lltok::kw_target:  if (ParseTargetDefinition()) return true; break;
-    case lltok::kw_source_filename:
-      if (ParseSourceFileName())
-        return true;
-      break;
     case lltok::kw_deplibs: if (ParseDepLibs()) return true; break;
     case lltok::LocalVarID: if (ParseUnnamedType()) return true; break;
     case lltok::LocalVar:   if (ParseNamedType()) return true; break;
     case lltok::GlobalID:   if (ParseUnnamedGlobal()) return true; break;
     case lltok::GlobalVar:  if (ParseNamedGlobal()) return true; break;
     case lltok::ComdatVar:  if (parseComdat()) return true; break;
     case lltok::exclaim:    if (ParseStandaloneMetadata()) return true; break;
     case lltok::SummaryID:

llvm/test/Analysis/DependenceAnalysis/NonCanonicalizedSubscript.ll

; DELIN: da analyze - none!
   %i.inc = add nsw i64 %i, 1
   %exitcond = icmp ne i64 %i.inc, 100
   br i1 %exitcond, label %for.body, label %for.end
 
 for.end:
   ret void
 }
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-
 ;  unsigned i, j;
 ;  for (i = 1; i < SIZE; i++) {
 ;    for (j = i; j < SIZE; j++) {
 ;      a[i][j] = a[i+1][j-1] + 2;
 ;    }
 ;  }
 ;  Extends the previous example to coupled MIV subscripts.
 

llvm/test/Analysis/ScalarEvolution/2012-05-29-MulAddRec.ll

 ; RUN: opt < %s -S -indvars -loop-unroll | FileCheck %s
 ;
 ; loop-unroll fully unrolls the inner loop, creating an interesting
 ; chain of multiplication. indvars forces SCEV to run again on the
 ; outer loop. While reducing the recurrence at %mul3, unsigned integer overflow
 ; causes one of the terms to reach zero. This forces all multiples in
 ; the recurrence to be zero, reducing the whole thing to a constant expression.
 ;
 ; PR12929: cast<Ty>() argument of incompatible type
 
+target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
+
 declare void @use(i8 %x)
 
 ; CHECK: @func
 ; CHECK: for.cond:
 ; CHECK: %inc1 = phi i8 [ 0, %entry ], [ %0, %for.body ]
 ; CHECK: br label %for.body
 
 ; CHECK: for.body:
 ; CHECK: %inc.9 = add i8 %inc.8, 1
 ; CHECK: %0 = add i8 %inc1, 10
 ; CHECK: br label %for.cond
 
-target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 define void @func() noreturn nounwind uwtable ssp {
 entry:
   br label %for.cond
 
 for.cond.loopexit:                                ; preds = %for.body
   %mul.lcssa = phi i8 [ %mul, %for.body ]
   %0 = add i8 %inc1, 10
   %indvars.iv.next = add i8 %indvars.iv, 10

llvm/test/Transforms/InstCombine/2012-09-17-ZeroSizedAlloca.ll

 ; RUN: opt -S -instcombine < %s | FileCheck %s
 
 ; When merging zero sized alloca check that requested alignments of the allocas
 ; are obeyed.
 
-@x = global i8* null, align 8
-@y = global i8* null, align 8
-
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.8.0"
 
+@x = global i8* null, align 8
+@y = global i8* null, align 8
+
 ; CHECK-LABEL: @f(
 ; CHECK-NEXT: alloca [0 x i8], align 1024
 ; CHECK-NOT: alloca
 ; CHECK: ret void
 define void @f() {
   %1 = alloca [0 x i8], align 1
   %2 = alloca [0 x i8], align 1024
   %3 = getelementptr inbounds [0 x i8], [0 x i8]* %1, i64 0, i64 0
   %4 = getelementptr inbounds [0 x i8], [0 x i8]* %2, i64 0, i64 0
   store i8* %3, i8** @x, align 8
   store i8* %4, i8** @y, align 8
   ret void
 }

llvm/test/Transforms/InstCombine/getelementptr-folding.ll

 ; RUN: opt -instcombine -S < %s | FileCheck %s
 
-%struct.matrix_float3x3 = type { [3 x <3 x float>] }
-
 ; We used to fold this by rewriting the indices to 0, 0, 2, 0.  This is
 ; invalid because there is a 4-byte padding after each <3 x float> field.
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
+%struct.matrix_float3x3 = type { [3 x <3 x float>] }
+
 @matrix_identity_float3x3 = external global %struct.matrix_float3x3, align 16
 @bbb = global float* getelementptr inbounds (%struct.matrix_float3x3, %struct.matrix_float3x3* @matrix_identity_float3x3, i64 0, i32 0, i64 1, i64 3)
 ; CHECK: @bbb = global float* getelementptr inbounds (%struct.matrix_float3x3, %struct.matrix_float3x3* @matrix_identity_float3x3, i64 0, i32 0, i64 1, i64 3)

llvm/test/Transforms/InstCombine/overflow-mul.ll

 ; RUN: opt -S -instcombine < %s | FileCheck %s
 
+; The last test needs this weird datalayout.
+target datalayout = "i32:8:8"
+; Without it, InstCombine will align the pointed on 4 Bytes
+; The KnownBitsZero that result from the alignment allows to
+; turn:
+;    and i32 %mul, 255
+; to:
+;    and i32 %mul, 252
+; The mask is no longer in the form 2^n-1  and this prevents the transformation.
+
+
 ; return mul(zext x, zext y) > MAX
 define i32 @pr4917_1(i32 %x, i32 %y) nounwind {
 ; CHECK-LABEL: @pr4917_1(
 entry:
   %l = zext i32 %x to i64
   %r = zext i32 %y to i64
 ; CHECK-NOT: zext i32
   %mul64 = mul i64 %l, %r
; CHECK: ret
   %vmovl.i.i712 = zext <4 x i16> %b to <4 x i32>
   %mul.i703 = mul <4 x i32> %vmovl.i.i712, %vmovl.i.i726
   %tmp = icmp sge <4 x i32> %mul.i703, zeroinitializer
   %vcgez.i = sext <4 x i1> %tmp to <4 x i32>
   ret <4 x i32> %vcgez.i
 }
 
 
-; The last test needs this weird datalayout.
-target datalayout = "i32:8:8"
-; Without it, InstCombine will align the pointed on 4 Bytes
-; The KnownBitsZero that result from the alignment allows to
-; turn:
-;    and i32 %mul, 255
-; to:
-;    and i32 %mul, 252
-; The mask is no longer in the form 2^n-1  and this prevents the transformation.
-
 @pr21445_data = external global i32
 define i1 @pr21445(i8 %a) {
 ; CHECK-LABEL: @pr21445(
 ; CHECK-NEXT:  %[[umul:.*]] = call { i8, i1 } @llvm.umul.with.overflow.i8(i8 %a, i8 ptrtoint (i32* @pr21445_data to i8))
 ; CHECK-NEXT:  %[[cmp:.*]] = extractvalue { i8, i1 } %[[umul]], 1
 ; CHECK-NEXT:  ret i1 %[[cmp]]
   %ext = zext i8 %a to i32
   %mul = mul i32 %ext, zext (i8 ptrtoint (i32* @pr21445_data to i8) to i32)
   %and = and i32 %mul, 255
   %cmp = icmp ne i32 %mul, %and
   ret i1 %cmp
 }

llvm/test/Transforms/InstCombine/wcslen-3.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Test that the wcslen library call simplifier works correctly.
 ;
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+
 ; Test behavior for wchar_size==2
 !llvm.module.flags = !{!0}
 !0 = !{i32 1, !"wchar_size", i32 2}
 
-target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
-
 declare i64 @wcslen(i16*)
 
 @hello = constant [6 x i16] [i16 104, i16 101, i16 108, i16 108, i16 111, i16 0]
 @longer = constant [7 x i16] [i16 108, i16 111, i16 110, i16 103, i16 101, i16 114, i16 0]
 @null = constant [1 x i16] zeroinitializer
 @null_hello = constant [7 x i16] [i16 0, i16 104, i16 101, i16 108, i16 108, i16 111, i16 0]
 @nullstring = constant i16 0
 @a = common global [32 x i16] zeroinitializer, align 1

llvm/test/Transforms/LoopIdiom/X86/popcnt.ll

 ; RUN: opt -loop-idiom < %s -mtriple=x86_64-apple-darwin -mcpu=corei7 -S | FileCheck %s
 
+target triple = "x86_64-apple-macosx10.8.0"
+
 ;To recognize this pattern:
 ;int popcount(unsigned long long a) {
 ;    int c = 0;
 ;    while (a) {
 ;        c++;
 ;        a &= a - 1;
 ;    }
 ;    return c;
while.end:                                        ; preds = %while.body, %entry
   %mydata2.addr.0.lcssa = phi i32 [ %mydata2, %entry ], [ %mul1, %while.body ]
   %mydata1.addr.0.lcssa = phi i32 [ %mydata1, %entry ], [ %mul, %while.body ]
   %add = add i32 %mydata2.addr.0.lcssa, %mydata1.addr.0.lcssa
   %add2 = add i32 %add, %c.0.lcssa
   ret i32 %add2
 }
 
 ; Some variants once cause crash
-target triple = "x86_64-apple-macosx10.8.0"
 
 define i32 @PopCntCrash1(i64 %a) nounwind uwtable readnone ssp {
 entry:
   %tobool3 = icmp eq i64 %a, 0
   br i1 %tobool3, label %while.end, label %while.body
 
 while.body:                                       ; preds = %entry, %while.body
   %c.05 = phi i32 [ %inc, %while.body ], [ 0, %entry ]

llvm/test/Transforms/LoopVectorize/explicit_outer_nonuniform_inner.ll

 
 
 ; Case 2 (for (j = 0; j < i; j++)): Inner loop with divergent upper-bound.
 
 ; CHECK-LABEL: loop_ub
 ; CHECK: LV: Not vectorizing: Outer loop contains divergent loops.
 ; CHECK: LV: Not vectorizing: Unsupported outer loop.
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 define void @loop_ub(i32* nocapture %a, i32* nocapture readonly %b, i32 %N, i32 %M) local_unnamed_addr {
 entry:
   %cmp32 = icmp sgt i32 %N, 0
   br i1 %cmp32, label %outer.ph, label %for.end15
 
 outer.ph:                                   ; preds = %entry
   %0 = sext i32 %M to i64
   %wide.trip.count41 = zext i32 %N to i64

 }
 
 ; Case 3 (for (j = 0; j < M; j+=i)): Inner loop with divergent step.
 
 ; CHECK-LABEL: iv_step
 ; CHECK: LV: Not vectorizing: Outer loop contains divergent loops.
 ; CHECK: LV: Not vectorizing: Unsupported outer loop.
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 define void @iv_step(i32* nocapture %a, i32* nocapture readonly %b, i32 %N, i32 %M) local_unnamed_addr {
 entry:
   %cmp33 = icmp sgt i32 %N, 0
   br i1 %cmp33, label %outer.ph, label %for.end15
 
 outer.ph:                                   ; preds = %entry
   %cmp231 = icmp sgt i32 %M, 0
   %0 = sext i32 %M to i64

llvm/test/Transforms/LoopVectorize/explicit_outer_uniform_diverg_branch.ll

 
 
 ; Case 2 (COND => B[i * M] == 0): Outer loop with divergent conditional branch.
 
 ; CHECK-LABEL: divergent_branch
 ; CHECK: Unsupported conditional branch.
 ; CHECK: LV: Not vectorizing: Unsupported outer loop.
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 define void @divergent_branch(i32* nocapture %a, i32* nocapture readonly %b, i32 %N, i32 %M) local_unnamed_addr {
 entry:
   %cmp39 = icmp sgt i32 %N, 0
   br i1 %cmp39, label %outer.ph, label %for.end19
 
 outer.ph:                                   ; preds = %entry
   %cmp337 = icmp slt i32 %M, 1
   %0 = sext i32 %M to i64

llvm/test/Transforms/NewGVN/pr33187.ll

bb1:                                              ; preds = %bb1, %bb
   %tmp = phi i64 [ 0, %bb ], [ %tmp2, %bb1 ]
   %tmp2 = add nuw nsw i64 %tmp, 1
   br label %bb1
 }
 
 attributes #0 = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 
-source_filename = "pr33187-c.ll"
-
 define void @a() {
 ; CHECK-LABEL: @a(
 ; CHECK-NEXT:  b:
 ; CHECK-NEXT:    store i8* null, i8** null
 ; CHECK-NEXT:    br label [[D:%.*]]
 ; CHECK:       d:
 ; CHECK-NEXT:    [[I:%.*]] = phi i8* [ null, [[B:%.*]] ], [ [[E:%.*]], [[F:%.*]] ]
 ; CHECK-NEXT:    br i1 undef, label [[F]], label [[G:%.*]]

llvm/test/Transforms/NewGVN/refine-stores.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s
 ;; Now that we do store refinement, we have to verify that we add fake uses
 ;; when we skip existing stores.
 ;; We also are testing that various variations that cause stores to move classes
 ;; have the right class movement happen
 ;; All of these tests result in verification failures if it does not.
+
+source_filename = "bugpoint-output-daef094.bc"
+target triple = "x86_64-apple-darwin16.5.0"
+
 %struct.eggs = type {}
 
 define void @spam(i32 *%a) {
 ; CHECK-LABEL: @spam(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[FOO:%.*]] = bitcast i32* [[A:%.*]] to %struct.eggs**
 ; CHECK-NEXT:    store %struct.eggs* null, %struct.eggs** [[FOO]]
 ; CHECK-NEXT:    br label [[BB1:%.*]]

 ;; The memory for this load starts out equivalent to just the store in c, we later discover the store after us, and
 ;; need to make sure the right set of values get marked as changed after memory leaders change
   %g = load i64*, i64** null
   %0 = bitcast i64* %g to i64*
   store i64* undef, i64** null
   br i1 undef, label %c, label %e
 }
 
-; ModuleID = 'bugpoint-reduced-simplified.bc'
-source_filename = "bugpoint-output-daef094.bc"
-target triple = "x86_64-apple-darwin16.5.0"
-
 %struct.hoge = type {}
 
 define void @widget(%struct.hoge* %arg) {
 ; CHECK-LABEL: @widget(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    br label [[BB1:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[TMP:%.*]] = phi %struct.hoge* [ [[ARG:%.*]], [[BB:%.*]] ], [ null, [[BB1]] ]
bb5:                                              ; preds = %bb2
   br label %bb7
 
 bb7:                                              ; preds = %bb5, %bb2
   %tmp8 = add i64 %tmp3, 1
   br label %bb2
 }
 
 declare void @quux()
-; ModuleID = 'short.ll'
-source_filename = "short.ll"
 
 %struct.a = type {}
 
 define void @b() {
 ; CHECK-LABEL: @b(
 ; CHECK-NEXT:    [[C:%.*]] = alloca [[STRUCT_A:%.*]]
 ; CHECK-NEXT:    br label [[D:%.*]]
 ; CHECK:       m:

llvm/test/Transforms/SafeStack/X86/call.ll

 ; RUN: opt -safe-stack -S -mtriple=i386-pc-linux-gnu < %s -o - | FileCheck %s
 ; RUN: opt -safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
 @.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1
 
 ; no arrays / no nested arrays
 ; Requires no protector.
 
 define void @foo(i8* %a) nounwind uwtable safestack {
 entry:
   ; CHECK-LABEL: define void @foo(
   ; CHECK-NOT: __safestack_unsafe_stack_ptr
   ; CHECK: ret void
   %a.addr = alloca i8*, align 8
   store i8* %a, i8** %a.addr, align 8
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %0)
   ret void
 }
 
 declare i32 @printf(i8*, ...)
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-
 define void @call_memset(i64 %len) safestack {
 entry:
   ; CHECK-LABEL: define void @call_memset
   ; CHECK: @__safestack_unsafe_stack_ptr
   ; CHECK: ret void
   %q = alloca [10 x i8], align 1
   %arraydecay = getelementptr inbounds [10 x i8], [10 x i8]* %q, i32 0, i32 0
   call void @llvm.memset.p0i8.i64(i8* %arraydecay, i8 1, i64 %len, i1 false)