[LTO] Reject modules without datalayout

[davide]

Summary

As per our previous discussion, see https://llvm.org/bugs/show_bug.cgi?id=31123 for reference.
If you agree on the patch, I'll also update the gold/lld tests failing.

[mehdi_amini]

We should also handle Datalayout mismatch with what the target expects.

[mehdi_amini]

We usually avoid report_fatal_error in libraries.
We should be able to catch this early in the LTO::add(...) method and return an error.

[davide]

Prefer Error<T> instead to report_fatal_error()

[davide]

Upload correct diff (setDataLayout() calls removed). Thanks to Mehdi for noticing.

[mehdi_amini]

LGTM.

llvm/trunk/lib/LTO/LTO.cpp

Error LTO::add(std::unique_ptr<InputFile> Input,
   return Error::success();
 }
 
 Error LTO::addModule(InputFile &Input, InputFile::InputModule &IM,
                      const SymbolResolution *&ResI,
                      const SymbolResolution *ResE) {
   // FIXME: move to backend
   Module &M = *IM.Mod;
+
+  if (M.getDataLayoutStr().empty())
+    return make_error<StringError>("input module has no datalayout",
+                                    inconvertibleErrorCode());
+
   if (!Conf.OverrideTriple.empty())
     M.setTargetTriple(Conf.OverrideTriple);
   else if (M.getTargetTriple().empty())
     M.setTargetTriple(Conf.DefaultTriple);
 
   Expected<bool> HasThinLTOSummary = IM.BM.hasSummary();
   if (!HasThinLTOSummary)
     return HasThinLTOSummary.takeError();

llvm/trunk/lib/LTO/LTOBackend.cpp

if (IsThinLTO)
     PMB.populateThinLTOPassManager(passes);
   else
     PMB.populateLTOPassManager(passes);
   passes.run(Mod);
 }
 
 bool opt(Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
          bool IsThinLTO) {
-  Mod.setDataLayout(TM->createDataLayout());
   if (Conf.OptPipeline.empty())
     runOldPMPasses(Conf, Mod, TM, IsThinLTO);
   else
     runNewPMCustomPasses(Mod, TM, Conf.OptPipeline, Conf.AAPipeline,
                          Conf.DisableVerify);
   return !Conf.PostOptModuleHook || Conf.PostOptModuleHook(Task, Mod);
 }
 

llvm/trunk/lib/LTO/LTOModule.cpp

if (Triple.isOSDarwin()) {
     else if (Triple.getArch() == llvm::Triple::x86)
       CPU = "yonah";
     else if (Triple.getArch() == llvm::Triple::aarch64)
       CPU = "cyclone";
   }
 
   TargetMachine *target =
       march->createTargetMachine(TripleStr, CPU, FeatureStr, options, None);
-  M->setDataLayout(target->createDataLayout());
 
   std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target));
   Ret->parseSymbols();
   Ret->parseMetadata();
 
   return std::move(Ret);
 }
 

llvm/trunk/test/LTO/Resolution/X86/Inputs/common2.ll

-target triple = "x86_64-apple-macosx10.11.0"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
 
 @v = common global i16 0, align 4
 
 define i16 *@bar() {
  ret i16 *@v
-}
+}
 

llvm/trunk/test/LTO/Resolution/X86/Inputs/mixed_lto.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 declare i32 @g()
 define i32 @main() {
   call i32 @g()
   ret i32 0
 }

llvm/trunk/test/LTO/Resolution/X86/common2.ll

 ; Same as before, but reversing the order of the inputs
 ; RUN: llvm-lto2 %t2.bc %t1.bc -o %t.o -save-temps \
 ; RUN:  -r %t1.bc,v,px \
 ; RUN:  -r %t2.bc,v,px \
 ; RUN:  -r %t1.bc,foo,px \
 ; RUN:  -r %t2.bc,bar,px
 ; RUN: llvm-dis < %t.o.0.0.preopt.bc | FileCheck %s --check-prefix=BOTH-PREVAILED2
 
-
-
-target triple = "x86_64-apple-macosx10.11.0"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
 
 @v = common global i8 0, align 8
 
 ; LARGE-PREVAILED: @v = common global i16 0, align 8
 ; SMALL-PREVAILED: @v = common global [2 x i8] zeroinitializer, align 8
 ; BOTH-PREVAILED1: @v = common global i16 0, align 8
 ; BOTH-PREVAILED2: common global [2 x i8] zeroinitializer, align 8
 ; In this case the first is kept as external
 ; NONE-PREVAILED1: @v = external global i8, align 8
 ; NONE-PREVAILED2: @v = external global i16, align 4
 
 define i8 *@foo() {
  ret i8 *@v
 }

llvm/trunk/test/LTO/Resolution/X86/mixed_lto.ll

 ; NM1-DAG: U g
 
 ; Do the same test again, but with the regular and thin LTO modules in the same file.
 ; RUN: llvm-cat -b -o %t4.o %t2.o %t1.o
 ; RUN: llvm-lto2 -o %t5.o %t4.o -r %t4.o,main,px -r %t4.o,g, -r %t4.o,g,px
 ; RUN: llvm-nm %t5.o.0 | FileCheck %s --check-prefix=NM0
 ; RUN: llvm-nm %t5.o.1 | FileCheck %s --check-prefix=NM1
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 define i32 @g() {
   ret i32 0
 }

llvm/trunk/test/LTO/X86/diagnostic-handler-remarks-with-hotness.ll

 ; YAML-NEXT: Function:        main
 ; YAML-NEXT: Hotness:         300
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - Callee:          foo
 ; YAML-NEXT:   - String:          ' inlined into '
 ; YAML-NEXT:   - Caller:          main
 ; YAML-NEXT: ...
 
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-darwin"
 
 declare i32 @bar()
 
 define i32 @foo() {
   %a = call i32 @bar()
   ret i32 %a
 }

llvm/trunk/test/LTO/X86/diagnostic-handler-remarks.ll

 ; YAML-NEXT: Name:            Inlined
 ; YAML-NEXT: Function:        main
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - Callee:          foo
 ; YAML-NEXT:   - String:          ' inlined into '
 ; YAML-NEXT:   - Caller:          main
 ; YAML-NEXT: ...
 
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-darwin"
 
 declare i32 @bar()
 
 define i32 @foo() {
   %a = call i32 @bar()
   ret i32 %a
 }

llvm/trunk/test/LTO/X86/no-undefined-puts-when-implemented.ll

 ; RUN: llvm-as <%s >%t1
 ; RUN: llvm-lto -exported-symbol=_uses_puts -exported-symbol=_uses_printf -o - %t1 | \
 ; RUN: llvm-nm - | \
 ; RUN: FileCheck %s
 ; rdar://problem/16165191
 ; runtime library implementations should not be renamed
 
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-darwin11"
 
 @str = private unnamed_addr constant [13 x i8] c"hello world\0A\00"
 
 ; CHECK-NOT: U _puts
 ; CHECK: T _uses_printf
 ; CHECK: T _uses_puts
 define i32 @uses_puts(i32 %i) {

llvm/trunk/test/LTO/X86/triple-init.ll

 ; RUN: llvm-as < %s >%t1
 ; RUN: llvm-lto -exported-symbol=_main  -o %t2 %t1
 ; RUN: llvm-nm %t2 | FileCheck %s 
 
-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 datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9"
 
 declare double @pow(double, double)
 
 define double @main(double %x) {
 ; We check that LTO will be aware of target triple and apply pow to __exp10 transformation.
 ; CHECK: U ___exp10
   %retval = call double @pow(double 10.0, double %x)
   ret double %retval
 }

llvm/trunk/test/ThinLTO/X86/Inputs/distributed_import.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @G = internal global i32 7
 define i32 @g() {
 entry:
   %0 = load i32, i32* @G
   ret i32 %0
 }

llvm/trunk/test/ThinLTO/X86/distributed_import.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/distributed_import.ll -o %t2.bc
 
 ; RUN: llvm-lto2 %t1.bc %t2.bc -o %t.o -save-temps \
 ; RUN:     -thinlto-distributed-indexes \
 ; RUN:     -r=%t1.bc,g, \
 ; RUN:     -r=%t1.bc,f,px \
 ; RUN:     -r=%t2.bc,g,px
 ; RUN:  opt -function-import -summary-file %t1.bc.thinlto.bc %t1.bc -o %t1.out
 ; RUN: opt -function-import -summary-file %t2.bc.thinlto.bc %t2.bc -o %t2.out
 ; RUN: llvm-dis -o - %t2.out | FileCheck %s
 ; CHECK: @G.llvm.0
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 declare i32 @g(...)
 
 define void @f() {
 entry:
   call i32 (...) @g()
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/alias-1.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @a = global i32 42

llvm/trunk/test/tools/gold/X86/Inputs/available-externally.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @zed() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/cache.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @main() {
 entry:
   call void (...) @globalfunc()
   ret i32 0
 }
 
 declare void @globalfunc(...)

llvm/trunk/test/tools/gold/X86/Inputs/comdat.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 $c2 = comdat any
 $c1 = comdat any
 
 ; This is only present in this file. The linker will keep $c1 from the first
 ; file and this will be undefined.
 @will_be_undefined = global i32 1, comdat($c1)
 
 @v1 = weak_odr global i32 41, comdat($c2)

llvm/trunk/test/tools/gold/X86/Inputs/comdat2.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 $foo = comdat any
 @foo = global i8 1, comdat
 define void @zed() {
   call void @bar()
   ret void
 }
 define void @bar() comdat($foo) {
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/common.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @a = common global i32 0, align 4

llvm/trunk/test/tools/gold/X86/Inputs/common2.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @a = common global i8 0, align 16

llvm/trunk/test/tools/gold/X86/Inputs/common3.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @a = common global i8 0, align 1

llvm/trunk/test/tools/gold/X86/Inputs/ctors2.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @bar, i8* null }]
 
 define void @bar() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/drop-linkage.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 $foo = comdat any
 define linkonce void @foo() comdat {
   ret void
 }
 
 define void @bar() {
   call void @foo()
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/irmover-error.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 !0 = !{ i32 1, !"foo", i32 2 }
 
 !llvm.module.flags = !{ !0 }

llvm/trunk/test/tools/gold/X86/Inputs/linkonce-weak.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define weak_odr void @f() !dbg !4 {
   ret void, !dbg !10
 }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!7, !8}
 !llvm.ident = !{!9}
 

llvm/trunk/test/tools/gold/X86/Inputs/mixed_lto.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 declare i32 @g()
 define i32 @main() {
   call i32 @g()
   ret i32 0
 }

llvm/trunk/test/tools/gold/X86/Inputs/pr19901-1.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 define linkonce_odr hidden void @f() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/resolve-to-alias.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @bar = alias void (), void ()* @zed
 define void @zed() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/start-lib-common.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @x = common global i32 0, align 8

llvm/trunk/test/tools/gold/X86/Inputs/thinlto.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @g() {
 entry:
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/thinlto_alias.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 define weak void @weakfunc() {
 entry:
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/thinlto_archive1.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @g() {
 entry:
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/thinlto_archive2.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @h() {
 entry:
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/thinlto_empty.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"

llvm/trunk/test/tools/gold/X86/Inputs/thinlto_internalize.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 declare i32 @g()
 define i32 @main() {
   call i32 @g()
   ret i32 0
 }

llvm/trunk/test/tools/gold/X86/Inputs/thinlto_linkonceresolution.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 define linkonce_odr hidden void @f() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/thinlto_weak_resolution.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Alias are not optimized
 @linkonceodralias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias
 
 ; Alias are not optimized
 @linkoncealias = linkonce alias void (), void ()* @linkoncefuncwithalias
 

llvm/trunk/test/tools/gold/X86/Inputs/type-merge.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @zed() {
   call void @bar()
   ret void
 }
 declare void @bar()

llvm/trunk/test/tools/gold/X86/Inputs/type-merge2.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 %zed = type { i16 }
 define void @bar(%zed* %this)  {
   store %zed* %this, %zed** null
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/visibility.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @foo() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/Inputs/weak.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @a = weak global i32 41
 @c = global i32* @a

llvm/trunk/test/tools/gold/X86/alias.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/alias-1.ll -o %t2.o
 ; RUN: %gold -shared -o %t3.o -plugin %llvmshlibdir/LLVMgold.so %t2.o %t.o \
 ; RUN:  -plugin-opt=emit-llvm
 ; RUN: llvm-dis < %t3.o -o - | FileCheck %s
 
 ; CHECK-NOT: alias
 ; CHECK: @a = global i32 42
 ; CHECK-NEXT: @b = global i32 1
 ; CHECK-NOT: alias
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @a = weak alias i32, i32* @b
 @b = global i32 1

llvm/trunk/test/tools/gold/X86/alias2.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: %gold -shared -o %t2.bc -plugin %llvmshlibdir/LLVMgold.so %t.o -plugin-opt=emit-llvm
 ; RUN: llvm-dis %t2.bc -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @bar = alias void (), void ()* @zed
 define void @foo() {
   call void @bar()
   ret void
 }
 define void @zed() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/available-externally.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/available-externally.ll -o %t2.o
 
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o %t2.o -o %t3.o
 ; RUN: llvm-dis %t3.o -o - | FileCheck %s
 
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t2.o %t.o -o %t3.o
 ; RUN: llvm-dis %t3.o -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @foo() {
   call void @bar()
   call void @zed()
   ret void
 }
 define available_externally void @bar() {
   ret void
 }
 define available_externally void @zed() {
   ret void
 }
 
 ; CHECK-DAG: define available_externally void @bar() {
 ; CHECK-DAG: define void @zed() {

llvm/trunk/test/tools/gold/X86/bad-alias.ll

 ; RUN: llvm-as %s -o %t.o
 
 ; RUN: not %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o -o %t2.o 2>&1 | FileCheck %s
 
 ; CHECK: Unable to determine comdat of alias!
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @g1 = global i32 1
 @g2 = global i32 2
 
 @a = alias i32, inttoptr(i32 sub (i32 ptrtoint (i32* @g1 to i32),
                                   i32 ptrtoint (i32* @g2 to i32)) to i32*)

llvm/trunk/test/tools/gold/X86/bcsection.ll

 ; RUN: llvm-as -o %T/bcsection.bc %s
 
 ; RUN: llvm-mc -I=%T -filetype=obj -triple=x86_64-unknown-unknown -o %T/bcsection.bco %p/Inputs/bcsection.s
 ; RUN: llvm-nm -no-llvm-bc %T/bcsection.bco | count 0
 ; RUN: %gold -r -o %T/bcsection.o -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold.so %T/bcsection.bco
 ; RUN: llvm-nm -no-llvm-bc %T/bcsection.o | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-unknown"
 
 ; CHECK: main
 define i32 @main() {
   ret i32 0
 }

llvm/trunk/test/tools/gold/X86/cache.ll

 ; RUN: rm -Rf %t.cache && mkdir %t.cache
 ; RUN: %gold -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:     --plugin-opt=thinlto \
 ; RUN:     --plugin-opt=cache-dir=%t.cache \
 ; RUN:     -o %t3.o %t2.o %t.o
 
 ; RUN: ls %t.cache | count 2
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @globalfunc() #0 {
 entry:
   ret void
 }

llvm/trunk/test/tools/gold/X86/coff.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so -plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o -o %t2.o
 ; RUN: llvm-dis %t2.o -o - | FileCheck %s
 
-
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target datalayout = "m:w"
 
 ; CHECK: define void @f() {
 define void @f() {
   ret void
 }
 
 ; CHECK: define internal void @g() {
 define hidden void @g() {
   ret void
 }
 
 ; CHECK: define internal void @h() {
 define linkonce_odr void @h() local_unnamed_addr {
   ret void
 }

llvm/trunk/test/tools/gold/X86/comdat.ll

 ; RUN: llvm-as %s -o %t1.o
 ; RUN: llvm-as %p/Inputs/comdat.ll -o %t2.o
 ; RUN: %gold -shared -o %t3.o -plugin %llvmshlibdir/LLVMgold.so %t1.o %t2.o \
 ; RUN:  -plugin-opt=save-temps
 ; RUN: FileCheck --check-prefix=RES %s < %t3.o.resolution.txt
 ; RUN: llvm-readobj -t %t3.o | FileCheck --check-prefix=OBJ %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 $c1 = comdat any
 
 @v1 = weak_odr global i32 42, comdat($c1)
 define weak_odr i32 @f1(i8*) comdat($c1) {
 bb10:
   br label %bb11
 bb11:
   ret i32 42

llvm/trunk/test/tools/gold/X86/comdat2.ll

 ; RUN: llvm-as %s -o %t.bc
 ; RUN: llvm-as %p/Inputs/comdat2.ll -o %t2.bc
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t.bc %t2.bc -o %t3.bc
 ; RUN: llvm-dis %t3.bc -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 $foo = comdat any
 @foo = global i8 0, comdat
 
 ; CHECK: @foo = global i8 0, comdat
 
 ; CHECK: define void @zed() {
 ; CHECK:   call void @bar()
 ; CHECK:   ret void
 ; CHECK: }
 
 ; CHECK: declare void @bar()

llvm/trunk/test/tools/gold/X86/common.ll

 ; RUN: llvm-as %s -o %t1.o
 ; RUN: llvm-as %p/Inputs/common.ll -o %t2.o
 ; RUN: llvm-as %p/Inputs/common2.ll -o %t2b.o
 ; RUN: llvm-as %p/Inputs/common3.ll -o %t2c.o
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @a = common global i16 0, align 8
 
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t1.o %t2.o -o %t3.o
 ; RUN: llvm-dis %t3.o -o - | FileCheck %s --check-prefix=A
 
 ; Shared library case, we merge @a as common and keep it for the symbol table.

llvm/trunk/test/tools/gold/X86/ctors.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o -o %t2.o
 ; RUN: llvm-dis %t2.o -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @foo, i8* null }]
 
 define internal void @foo() {
   ret void
 }
 
 ; CHECK: @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @foo, i8* null }]

llvm/trunk/test/tools/gold/X86/ctors2.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/ctors2.ll -o %t2.o
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o %t2.o -o %t3.o
 ; RUN: llvm-dis %t3.o -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @foo, i8* null }]
 
 define void @foo() {
   ret void
 }
 
 ; CHECK: @llvm.global_ctors = appending global [2 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @foo, i8* null }, { i32, void ()*, i8* } { i32 65535, void ()* @bar, i8* null }]

llvm/trunk/test/tools/gold/X86/disable-verify.ll

 ; RUN: llvm-as %s -o %t.o
 ; REQUIRES: asserts
 
 ; RUN: %gold -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=disable-verify \
 ; RUN:    --plugin-opt=-debug-pass=Arguments \
 ; RUN:    -shared %t.o -o %t2.o 2>&1 | FileCheck %s
 
 ; RUN: %gold -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=-debug-pass=Arguments \
 ; RUN:    -shared %t.o -o %t2.o 2>&1 | FileCheck %s -check-prefix=VERIFY
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; -disable-verify should disable output verification from the optimization
 ; pipeline.
 ; CHECK: Pass Arguments: {{.*}} -verify -
 ; CHECK-NOT: -verify
 
 ; VERIFY: Pass Arguments: {{.*}} -verify {{.*}} -verify
 
 define void @f() {
 entry:
   ret void
 }

llvm/trunk/test/tools/gold/X86/drop-linkage.ll

 ; RUN: llc %s -o %t.s
 ; RUN: llvm-mc %t.s -o %t.o -filetype=obj
 ; RUN: llvm-as %p/Inputs/drop-linkage.ll -o %t2.o
 
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o %t2.o -o %t3.o
 ; RUN: llvm-dis %t3.o -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @foo() {
   ret void
 }
 
 ; CHECK: declare void @foo()

llvm/trunk/test/tools/gold/X86/emit-llvm.ll

 ; RUN: rm -f %t4.o
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:     -m elf_x86_64 --plugin-opt=disable-output \
 ; RUN:    -shared %t.o -o %t4.o
 ; RUN: not test -a %t4.o
 
 ; NM: T f3
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-DAG: @g1 = weak_odr constant i32 32
 @g1 = linkonce_odr constant i32 32
 
 ; CHECK-DAG: @g2 = internal constant i32 32
 @g2 = linkonce_odr local_unnamed_addr constant i32 32
 

llvm/trunk/test/tools/gold/X86/irmover-error.ll

 ; RUN: llvm-as -o %t1.bc %s
 ; RUN: llvm-as -o %t2.bc %S/Inputs/irmover-error.ll
 ; RUN: not %gold -plugin %llvmshlibdir/LLVMgold.so -o %t %t1.bc %t2.bc 2>&1 | FileCheck %s
 
 ; CHECK: fatal error: Failed to link module {{.*}}2.bc: linking module flags 'foo': IDs have conflicting values
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 !0 = !{ i32 1, !"foo", i32 1 }
 
 !llvm.module.flags = !{ !0 }

llvm/trunk/test/tools/gold/X86/linker-script.ll

 ; RUN: llvm-as %s -o %t.o
 
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o -o %t2.o \
 ; RUN:    -version-script=%p/Inputs/linker-script.export
 ; RUN: llvm-dis %t2.o -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 ; CHECK: define void @f()
 define void @f() {
   ret void
 }
 
 ; CHECK: define internal void @g()
 define void @g() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/linkonce-weak.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/linkonce-weak.ll -o %t2.o
 
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o %t2.o -o %t3.o
 ; RUN: llvm-dis %t3.o -o - | FileCheck %s
 
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t2.o %t.o -o %t3.o
 ; RUN: llvm-dis %t3.o -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define linkonce_odr void @f() !dbg !4 {
   ret void, !dbg !10
 }
 
 ; Test that we get a weak_odr regardless of the order of the files
 ; CHECK: define weak_odr void @f()
 
 ; Test that we only get a single DISubprogram for @f

llvm/trunk/test/tools/gold/X86/mixed_lto.ll

 ; Test mixed-mode LTO (mix of regular and thin LTO objects)
 ; RUN: opt %s -o %t.o
 ; RUN: opt -module-summary %p/Inputs/mixed_lto.ll -o %t2.o
 
 ; RUN: %gold -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:     -shared \
 ; RUN:     --plugin-opt=thinlto \
 ; RUN:     --plugin-opt=-import-instr-limit=0 \
 ; RUN:     -o %t3.o %t2.o %t.o
 ; RUN: llvm-nm %t3.o | FileCheck %s
 
 ; CHECK-DAG: T main
 ; CHECK-DAG: T g
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 define i32 @g() {
   ret i32 0
 }

llvm/trunk/test/tools/gold/X86/no-map-whole-file.ll

 ; RUN: llvm-as -o %t.bc %s
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so -plugin-opt=emit-llvm \
 ; RUN:    --no-map-whole-files -r -o %t2.bc %t.bc
 ; RUN: llvm-dis < %t2.bc -o - | FileCheck %s
 
 ; CHECK: main
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define i32 @main() {
   ret i32 0
 }

llvm/trunk/test/tools/gold/X86/opt-level.ll

 ; RUN: llvm-as -o %t.bc %s
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so -plugin-opt=save-temps \
 ; RUN:    -plugin-opt=O0 -r -o %t.o %t.bc
 ; RUN: llvm-dis < %t.o.0.4.opt.bc -o - | FileCheck --check-prefix=CHECK-O0 %s
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so -plugin-opt=save-temps \
 ; RUN:    -plugin-opt=O1 -r -o %t.o %t.bc
 ; RUN: llvm-dis < %t.o.0.4.opt.bc -o - | FileCheck --check-prefix=CHECK-O1 %s
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so -plugin-opt=save-temps \
 ; RUN:    -plugin-opt=O2 -r -o %t.o %t.bc
 ; RUN: llvm-dis < %t.o.0.4.opt.bc -o - | FileCheck --check-prefix=CHECK-O2 %s
 
 ; CHECK-O0: define internal void @foo(
 ; CHECK-O1: define internal void @foo(
 ; CHECK-O2-NOT: define internal void @foo(
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define internal void @foo() {
   ret void
 }
 
 ; CHECK-O0: define internal i32 @bar(
 ; CHECK-O1: define internal i32 @bar(
 define internal i32 @bar(i1 %p) {
   br i1 %p, label %t, label %f

llvm/trunk/test/tools/gold/X86/parallel.ll

 ; RUN: llvm-as -o %t.bc %s
 ; RUN: rm -f %t.opt.bc0 %t.opt.bc1 %t.o0 %t.o1
 ; RUN: env LD_PRELOAD=%llvmshlibdir/LLVMgold.so %gold -plugin %llvmshlibdir/LLVMgold.so -u foo -u bar -plugin-opt lto-partitions=2 -plugin-opt save-temps -m elf_x86_64 -o %t %t.bc
 ; RUN: llvm-dis %t.0.5.precodegen.bc -o - | FileCheck --check-prefix=CHECK-BC0 %s
 ; RUN: llvm-dis %t.1.5.precodegen.bc -o - | FileCheck --check-prefix=CHECK-BC1 %s
 ; RUN: llvm-nm %t.o0 | FileCheck --check-prefix=CHECK0 %s
 ; RUN: llvm-nm %t.o1 | FileCheck --check-prefix=CHECK1 %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-BC0: define void @foo
 ; CHECK-BC0: declare void @bar
 ; CHECK0-NOT: bar
 ; CHECK0: T foo
 ; CHECK0-NOT: bar
 define void @foo() {

llvm/trunk/test/tools/gold/X86/pr19901.ll

 ; CHECK-NEXT:    Size:
 ; CHECK-NEXT:    Binding: Local
 ; CHECK-NEXT:    Type: Function
 ; CHECK-NEXT:    Other
 ; CHECK-NOT:     Seciton
 ; CHECK:         Section: .text
 ; CHECK-NEXT:  }
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 define i32 @g() {
   call void @f()
   ret i32 0
 }
 define linkonce_odr hidden void @f() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/pr19901_thinlto.ll

 ; CHECK-NEXT:    Size:
 ; CHECK-NEXT:    Binding: Local
 ; CHECK-NEXT:    Type: Function
 ; CHECK-NEXT:    Other
 ; CHECK-NOT:     Seciton
 ; CHECK:         Section: .text
 ; CHECK-NEXT:  }
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 define i32 @g() {
   call void @f()
   ret i32 0
 }
 define linkonce_odr hidden void @f() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/pr25907.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    -shared %t.o -o %t2
 ; RUN: llvm-nm %t2 | FileCheck %s
 ; CHECK: T main
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @main.L = internal unnamed_addr constant [3 x i8*] [i8* blockaddress(@main, %L1), i8* blockaddress(@main, %L2), i8* null], align 16
 
 define i32 @main() #0 {
 entry:
   br label %L1
 
 L1:                                               ; preds = %entry, %L1
   %i.0 = phi i32 [ 0, %entry ], [ %inc, %L1 ]

llvm/trunk/test/tools/gold/X86/pr25915.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    -plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o -o %t2
 ; RUN: llvm-dis %t2 -o - | FileCheck %s
 ; CHECK-NOT: subprograms
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4}
 !llvm.ident = !{!5}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.8.0 (trunk 256170) (llvm/trunk 256171)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
 !1 = !DIFile(filename: "pr25915.cc", directory: ".")
 !2 = !{}
 !3 = !{i32 2, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{!"clang version 3.8.0 (trunk 256170) (llvm/trunk 256171)"}

llvm/trunk/test/tools/gold/X86/relax-relocs.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: %gold -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=save-temps \
 ; RUN:    -shared %t.o -o %t.so
 ; RUN: llvm-readobj -r %t.so.o | FileCheck %s
 
 ; Test that we produce R_X86_64_GOTPCREL instead of R_X86_64_GOTPCRELX
 ; CHECK: R_X86_64_GOTPCREL foo
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @foo = external global i32
 define i32 @bar() {
   %t = load i32, i32* @foo
   ret i32 %t
 }

llvm/trunk/test/tools/gold/X86/resolve-to-alias.ll

 
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t2.o %t.o -o %t.bc
 ; RUN: llvm-dis %t.bc -o %t.ll
 ; RUN: FileCheck --check-prefix=PASS1 %s < %t.ll
 ; RUN: FileCheck --check-prefix=PASS2 %s < %t.ll
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @foo() {
   call void @bar()
   ret void
 }
 declare void @bar()
 
 ; PASS1: @bar = alias void (), void ()* @zed
 
 ; PASS1:      define void @foo() {
 ; PASS1-NEXT:   call void @bar()
 ; PASS1-NEXT:   ret void
 ; PASS1-NEXT: }
 
 ; PASS2:      define void @zed() {
 ; PASS2-NEXT:   ret void
 ; PASS2-NEXT: }

llvm/trunk/test/tools/gold/X86/slp-vectorize.ll

 ; RUN: llvm-as %s -o %t.o
 
 ; RUN: %gold -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=save-temps \
 ; RUN:    -shared %t.o -o %t2.o
 ; RUN: llvm-dis %t2.o.0.4.opt.bc -o - | FileCheck %s
 
 ; test that the vectorizer is run.
 ; CHECK: fadd <4 x float>
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @f(float* nocapture %x) {
   %tmp = load float, float* %x, align 4
   %add = fadd float %tmp, 1.000000e+00
   store float %add, float* %x, align 4
   %arrayidx1 = getelementptr inbounds float, float* %x, i64 1
   %tmp1 = load float, float* %arrayidx1, align 4

llvm/trunk/test/tools/gold/X86/start-lib-common.ll

 ; Test the case when the preferred (larger / more aligned) version of a common
 ; symbol is located in a module that's not included in the link.
 
 ; RUN: llvm-as %s -o %t1.o
 ; RUN: llvm-as %p/Inputs/start-lib-common.ll -o %t2.o
 
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t1.o --start-lib %t2.o --end-lib -o %t3.o
 ; RUN: llvm-dis %t3.o -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 @x = common global i32 0, align 4
 
 ; ToT gold (as of 03/2016) honors --start-lib/--end-lib, drops %t2.o and ends up
 ; with (i32 align 4) symbol.
 ; Older gold does not drop %t2.o and ends up with (i32 align 8) symbol. This is
 ; incorrect behavior, but this test does not verify this in order to support
 ; both old and new gold.
 
 ; Check that the common symbol is not dropped completely, which was a regression
 ; in r262676.
 ; CHECK: @x = common global i32 0, align

llvm/trunk/test/tools/gold/X86/strip_names.ll

 
 ; NONAME: @GlobalValueName
 ; NONAME: @foo(i32)
 ; NONAME-NOT: somelabel:
 ; NONAME:  %2 = load i32, i32* @GlobalValueName
 ; NONAME:  %3 = add i32 %0, %2
 ; NONAME:  ret i32 %3
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @GlobalValueName = global i32 0
 
 define i32 @foo(i32 %in) {
 somelabel:
   %GV = load i32, i32* @GlobalValueName
   %add = add i32 %in, %GV
   ret i32 %add
 }

llvm/trunk/test/tools/gold/X86/thinlto.ll

 ; COMBINED-NEXT: </GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED-NEXT: <VALUE_SYMTAB
 ; Check that the format is: op0=valueid, op1=offset, op2=funcguid,
 ; where funcguid is the lower 64 bits of the function name MD5.
 ; COMBINED-NEXT: <COMBINED_ENTRY abbrevid={{[0-9]+}} op0={{1|2}} op1={{-3706093650706652785|-5300342847281564238}}
 ; COMBINED-NEXT: <COMBINED_ENTRY abbrevid={{[0-9]+}} op0={{1|2}} op1={{-3706093650706652785|-5300342847281564238}}
 ; COMBINED-NEXT: </VALUE_SYMTAB
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 declare void @g(...)
 
 define void @f() {
 entry:
   call void (...) @g()
   ret void
 }

llvm/trunk/test/tools/gold/X86/thinlto_alias.ll

 ; during the ThinLTO backend. The internalization step implemented by IRMover
 ; for preempted symbols has not yet been implemented for the combined summary.
 ; XFAIL: *
 
 ; CHECK-NOT: U f
 ; OPT: define hidden void @weakfunc.llvm.0()
 ; OPT2: define weak void @weakfunc()
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @weakfuncAlias = alias void (...), bitcast (void ()* @weakfunc to void (...)*)
 define weak void @weakfunc() {
 entry:
   ret void
 }

llvm/trunk/test/tools/gold/X86/thinlto_archive.ll

 ; output messages are not interleaved.
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=thinlto \
 ; RUN:    --plugin-opt=-print-imports \
 ; RUN:    --plugin-opt=jobs=1 \
 ; RUN:    -shared %t.o %t.a -o %t4 2>&1 | FileCheck %s
 ; RUN: llvm-nm %t4 | FileCheck %s --check-prefix=NM
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 ; CHECK-DAG: Import g
 declare void @g(...)
 ; CHECK-DAG: Import h
 declare void @h(...)
 
 ; NM: T f
 define void @f() {
 entry:
   call void (...) @g()
   call void (...) @h()
   ret void
 }

llvm/trunk/test/tools/gold/X86/thinlto_emit_imports.ll

 ; RUN: cat %t2.o.imports | count 0
 
 ; The imports file for Input/thinlto_empty.ll is empty but should exist.
 ; RUN: cat %t3.o.imports | count 0
 
 ; The index file should be created even for the input with an empty summary.
 ; RUN: ls %t3.o.thinlto.bc
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 declare void @g(...)
 
 define void @f() {
 entry:
   call void (...) @g()
   ret void
 }

llvm/trunk/test/tools/gold/X86/thinlto_internalize.ll

 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: opt -module-summary %p/Inputs/thinlto_internalize.ll -o %t2.o
 
 ; RUN: %gold -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:     --plugin-opt=thinlto \
 ; RUN:     --plugin-opt=-import-instr-limit=0 \
 ; RUN:     --plugin-opt=save-temps \
 ; RUN:     -o %t3.o %t2.o %t.o
 ; RUN: llvm-dis %t.o.4.opt.bc -o - | FileCheck %s
 
 ; f() should be internalized and eliminated after inlining
 ; CHECK-NOT: @f()
 
 ; h() should be internalized after promotion, and eliminated after inlining
 ; CHECK-NOT: @h.llvm.
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 define i32 @g() {
   call void @f()
   call void @h()
   ret i32 0
 }
 define void @f() {
   ret void
 }
 define internal void @h() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/thinlto_linkonceresolution.ll

 ; RUN: llvm-dis %t2.o.4.opt.bc -o - | FileCheck --check-prefix=OPT2 %s
 
 ; Ensure that f() is defined in resulting object file, and also
 ; confirm the weak linkage directly in the saved opt bitcode files.
 ; CHECK-NOT: U f
 ; OPT-NOT: @f()
 ; OPT2: define weak_odr hidden void @f()
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 define i32 @g() {
   call void @f()
   ret i32 0
 }
 define linkonce_odr hidden void @f() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/thinlto_prefix_replace.ll

 ; Check that changing the output path via thinlto-prefix-replace works
 ; RUN: mkdir -p %T/oldpath
 ; RUN: opt -module-summary %s -o %T/oldpath/thinlto_prefix_replace.o
 ; Ensure that there is no existing file at the new path, so we properly
 ; test the creation of the new file there.
 ; RUN: rm -f %T/newpath/thinlto_prefix_replace.o.thinlto.bc
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=thinlto \
 ; RUN:    --plugin-opt=thinlto-index-only \
 ; RUN:    --plugin-opt=thinlto-prefix-replace="%T/oldpath/;%T/newpath/" \
 ; RUN:    -shared %T/oldpath/thinlto_prefix_replace.o -o %T/thinlto_prefix_replace
 ; RUN: ls %T/newpath/thinlto_prefix_replace.o.thinlto.bc
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @f() {
 entry:
   ret void
 }

llvm/trunk/test/tools/gold/X86/thinlto_weak_resolution.ll

 ; RUN: llvm-dis %t2.o.4.opt.bc -o - | FileCheck --check-prefix=OPT2 %s
 ; OPT2-NOT: @
 ; OPT2: @weakfunc
 ; OPT2-NOT: @
 
 ; RUN: llvm-dis %t.o.3.import.bc -o - | FileCheck --check-prefix=IMPORT %s
 ; RUN llvm-dis %t2.o.3.import.bc -o - | FileCheck --check-prefix=IMPORT2 %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 
 define i32 @main() #0 {
 entry:
   call void @linkonceodralias()
   call void @linkoncealias()
   call void @linkonceodrfuncwithalias()

llvm/trunk/test/tools/gold/X86/type-merge.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/type-merge.ll -o %t2.o
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o %t2.o -o %t3.o
 ; RUN: llvm-dis %t3.o -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @foo()  {
   call void @bar(i8* null)
   ret void
 }
 declare void @bar(i8*)
 
 ; CHECK:      define void @foo() {
 ; CHECK-NEXT:   call void @bar(i8* null)

llvm/trunk/test/tools/gold/X86/type-merge2.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/type-merge2.ll -o %t2.o
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=save-temps \
 ; RUN:    -shared %t.o %t2.o -o %t3.o
 ; RUN: llvm-dis %t3.o.0.2.internalize.bc -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 %zed = type { i8 }
 define void @foo()  {
   call void @bar(%zed* null)
   ret void
 }
 declare void @bar(%zed*)
 
 ; CHECK:      %zed = type { i8 }

llvm/trunk/test/tools/gold/X86/unnamed-addr.ll

 ; RUN: llvm-as %s -o %t.o
 
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o -o %t2.o
 ; RUN: llvm-dis %t2.o -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @a = internal unnamed_addr constant i8 42
 
 define i8* @f() {
   ret i8* @a
 }
 
 ; CHECK: @a = internal unnamed_addr constant i8 42

llvm/trunk/test/tools/gold/X86/visibility.ll

 ; CHECK-NEXT: Binding: Global
 ; CHECK-NEXT: Type: Function
 ; CHECK-NEXT: Other [
 ; CHECK-NEXT:   STV_PROTECTED
 ; CHECK-NEXT: ]
 
 ; IR: define void @foo
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define weak protected void @foo() {
   ret void
 }

llvm/trunk/test/tools/gold/X86/weak.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/weak.ll -o %t2.o
 
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:    --plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o %t2.o -o %t3.o
 ; RUN: llvm-dis %t3.o -o - | FileCheck %s
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @a = weak global i32 42
 @b = global i32* @a
 
 ; Test that @b and @c end up pointing to the same variable.
 
 ; CHECK: @a = weak global i32 42
 ; CHECK: @b = global i32* @a{{$}}
 ; CHECK: @c = global i32* @a{{$}}

llvm/trunk/test/tools/llvm-lto/Inputs/thinlto.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @g() {
 entry:
   ret void
 }

llvm/trunk/test/tools/llvm-lto/thinlto.ll

 ; COMBINED-NEXT: </GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED-NEXT: <VALUE_SYMTAB
 ; Check that the format is: op0=valueid, op1=offset, op2=funcguid,
 ; where funcguid is the lower 64 bits of the function name MD5.
 ; COMBINED-NEXT: <COMBINED_ENTRY abbrevid={{[0-9]+}} op0={{1|2}} op1={{-3706093650706652785|-5300342847281564238}}
 ; COMBINED-NEXT: <COMBINED_ENTRY abbrevid={{[0-9]+}} op0={{1|2}} op1={{-3706093650706652785|-5300342847281564238}}
 ; COMBINED-NEXT: </VALUE_SYMTAB
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 define void @f() {
 entry:
   ret void
 }

llvm/trunk/test/tools/llvm-lto2/X86/nodatalayout.ll

+; RUN: llvm-as < %s > %t1.bc
+
+; Reject input modules without a datalayout.
+; RUN: not llvm-lto2 %t1.bc -o %t.o \
+; RUN:  -r %t1.bc,patatino,px 2>&1 | FileCheck %s
+
+; CHECK: input module has no datalayout
+
+target triple = "x86_64-unknown-linux-gnu"
+
+define void @patatino() {
+  ret void
+}

llvm/trunk/test/tools/llvm-lto2/X86/pipeline.ll

 ; RUN: llvm-as < %s > %t1.bc
 
 ; Try a custom pipeline
 ; RUN: llvm-lto2 %t1.bc -o %t.o -save-temps \
 ; RUN:  -r %t1.bc,patatino,px -opt-pipeline loweratomic \
 ; RUN:  -aa-pipeline basic-aa
 ; RUN: llvm-dis < %t.o.0.4.opt.bc | FileCheck %s --check-prefix=CUSTOM
 
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @patatino() {
   fence seq_cst
   ret void
 }
 
 ; CUSTOM: define void @patatino() {

llvm/trunk/test/tools/llvm-lto2/errors.ll

 ; RUN: llvm-as %s -o %t.bc
 ; RUN: not llvm-lto2 -o %t2.o %t.bc 2>&1 | FileCheck --check-prefix=ERR1 %s
 ; RUN: not llvm-lto2 -o %t2.o -r %t.bc,foo,p -r %t.bc,bar,p %t.bc 2>&1 | FileCheck --check-prefix=ERR2 %s
 ; RUN: not llvm-lto2 -o %t2.o -r %t.bc,foo,q %t.bc 2>&1 | FileCheck --check-prefix=ERR3 %s
 ; RUN: not llvm-lto2 -o %t2.o -r foo %t.bc 2>&1 | FileCheck --check-prefix=ERR4 %s
 
 ; ERR1: missing symbol resolution for {{.*}}.bc,foo
 ; ERR2: unused symbol resolution for {{.*}}.bc,bar
 ; ERR3: invalid character q in resolution: {{.*}}.bc,foo
 ; ERR4: invalid resolution: foo
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
 @foo = global i32 0