Subzero: Track protos + globals w/out initializers as undef too (not just helper funcs)

tests_lit/llvm2ice_tests/elf_container.ll

 ; Tests that we generate an ELF container with fields that make sense,
 ; cross-validating against llvm-mc.
 
 ; For the integrated ELF writer, we can't pipe the output because we need
 ; to seek backward and patch up the file headers. So, use a temporary file.
 ; RUN: %p2i -i %s --args -O2 --verbose none -elf-writer -o %t \
 ; RUN:   && llvm-readobj -file-headers -sections -section-data \
 ; RUN:       -relocations -symbols %t | FileCheck %s
 
 ; RUN: %p2i -i %s --args -O2 --verbose none \
 ; RUN:   | llvm-mc -triple=i686-none-nacl -filetype=obj -o - \
 ; RUN:   | llvm-readobj -file-headers -sections -section-data \
 ; RUN:       -relocations -symbols - | FileCheck %s
 
 ; Add a run that shows relocations in code inline.
 ; RUN: %p2i -i %s --args -O2 --verbose none -elf-writer -o %t \
 ; RUN:   && llvm-objdump -d -r -x86-asm-syntax=intel %t \
 ; RUN:   | FileCheck --check-prefix=TEXT-RELOCS %s
 
 ; Use intrinsics to test external calls.
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1)
 declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i32, i1)
 
+; Try other external functions (for cross tests).
+; Not testing external global variables since the NaCl bitcode writer
+; refuses to freeze such IR.
+declare void @external_foo(i32)
+
 ; Test some global data relocs (data, rodata, bss).
 @bytes = internal global [7 x i8] c"ab\03\FF\F6fg", align 1
 @bytes_const = internal constant [7 x i8] c"ab\03\FF\F6fg", align 1
 
 @ptr = internal global i32 ptrtoint ([7 x i8]* @bytes to i32), align 16
 @ptr_const = internal constant i32 ptrtoint ([7 x i8]* @bytes to i32), align 16
 
 @ptr_to_func = internal global i32 ptrtoint (double ()* @returnDoubleConst to i32), align 4
 @ptr_to_func_const = internal constant i32 ptrtoint (double ()* @returnDoubleConst to i32), align 4
 
@@ skipping 56 matching lines @@
 }
 ; TEXT-RELOCS-LABEL: test_memset
 
 ; Test calling internal functions (may be able to do the fixup,
 ; without emitting a relocation).
 define internal float @test_call_internal() {
   %f = call float @returnFloatConst()
   ret float %f
 }
 
+; Test calling an external function.
+define internal void @test_call_external() {
+  call void @external_foo(i32 42)
+  ret void
+}
+
 ; Test copying a function pointer, or a global data pointer.
 define internal i32 @test_ret_fp() {
   %r = ptrtoint float ()* @returnFloatConst to i32
   ret i32 %r
 }
 ; TEXT-RELOCS-LABEL: test_ret_fp
 ; TEXT-RELOCS-NEXT: mov
 ; TEXT-RELOCS-NEXT: R_386_32 returnFloatConst
 
 define internal i32 @test_ret_global_pointer() {
@@ skipping 270 matching lines @@
 
 ; CHECK: Relocations [
 ; CHECK:   Section ({{[0-9]+}}) .rel.text {
 ; CHECK:     0x4 R_386_32 .L$float$0 0x0
 ; CHECK:     0xC R_386_32 .L$float$1 0x0
 ; CHECK:     0x24 R_386_32 .L$double$0 0x0
 ; CHECK:     0x2C R_386_32 .L$double$1 0x0
 ; CHECK:     0x34 R_386_32 .L$double$2 0x0
 ; CHECK:     0x{{.*}} R_386_PC32 memcpy
 ; CHECK:     0x{{.*}} R_386_PC32 memset
+; CHECK:     0x{{.*}} R_386_PC32 external_foo
 ; CHECK:   }
 ; CHECK:   Section ({{[0-9]+}}) .rel.data {
 ; The set of relocations between llvm-mc and the integrated elf-writer
 ; are different. For local symbols, llvm-mc uses the section + offset within
 ; the section, while the integrated elf-writer refers the symbol itself.
 ; CHECK:     0x10 R_386_32 {{.*}} 0x0
 ; CHECK:     0x14 R_386_32 {{.*}} 0x0
 ; CHECK:     0x18 R_386_32 {{.*}} 0x0
 ; CHECK:   }
 ; CHECK:   Section ({{[0-9]+}}) .rel.rodata {
@@ skipping 207 matching lines @@
 ; CHECK:        Symbol {
 ; CHECK:          Name: _start
 ; CHECK-NEXT:     Value: 0x{{[1-9A-F][0-9A-F]*}}
 ; CHECK-NEXT:     Size: 0
 ; CHECK-NEXT:     Binding: Global
 ; CHECK-NEXT:     Type: Function
 ; CHECK-NEXT:     Other: 0
 ; CHECK-NEXT:     Section: .text
 ; CHECK-NEXT:   }
 ; CHECK:        Symbol {
+; CHECK:          Name: external_foo
+; CHECK-NEXT:     Value: 0x0
+; CHECK-NEXT:     Size: 0
+; CHECK-NEXT:     Binding: Global
+; CHECK-NEXT:     Type: None
+; CHECK-NEXT:     Other: 0
+; CHECK-NEXT:     Section: Undefined
+; CHECK-NEXT:   }
+; CHECK:        Symbol {
 ; CHECK:          Name: memcpy
 ; CHECK-NEXT:     Value: 0x0
 ; CHECK-NEXT:     Size: 0
 ; CHECK-NEXT:     Binding: Global
 ; CHECK-NEXT:     Type: None
 ; CHECK-NEXT:     Other: 0
 ; CHECK-NEXT:     Section: Undefined
 ; CHECK-NEXT:   }
 ; CHECK:        Symbol {
 ; CHECK:          Name: memset
 ; CHECK-NEXT:     Value: 0x0
 ; CHECK-NEXT:     Size: 0
 ; CHECK-NEXT:     Binding: Global
 ; CHECK-NEXT:     Type: None
 ; CHECK-NEXT:     Other: 0
 ; CHECK-NEXT:     Section: Undefined
 ; CHECK-NEXT:   }
 ; CHECK: ]