llvm/test/ExecutionEngine/JITLink/X86/MachO_x86-64_relocations.s

   1 # RUN: rm -rf %t && mkdir -p %t
   2 # RUN: llvm-mc -triple=x86_64-apple-macosx10.9 -filetype=obj -o %t/macho_reloc.o %s
   3 # RUN: llvm-jitlink -noexec -slab-allocate 100Kb -slab-address 0xfff00000 \
   4 # RUN:    -define-abs external_data=0x1 -define-abs external_func=0x2 \
   5 # RUN:    -check=%s %t/macho_reloc.o
   6 #
   7 # Test standard MachO relocations. Simulates slab allocation in the top 1Mb of
   8 # memory and places external symbols in the lowest page to prevent GOT and stub
   9 # elimination.
  10
  11         .section        __TEXT,__text,regular,pure_instructions
  12
  13 # Check that common symbols work.
  14 # jitlink-check: *{4}common_symbol = 0
  15 # jitlink-check: common_symbol[1:0] = 0
  16 .comm   common_symbol,4,2
  17
  18         .align  4, 0x90
  19 Lanon_func:
  20         retq
  21
  22         .globl  named_func
  23         .align  4, 0x90
  24 named_func:
  25         xorq    %rax, %rax
  26         retq
  27
  28 # Check X86_64_RELOC_BRANCH handling with a call to a local function.
  29 #
  30 # jitlink-check: decode_operand(test_local_call, 0) = named_func - next_pc(test_local_call)
  31         .globl  test_local_call
  32         .align  4, 0x90
  33 test_local_call:
  34         callq   named_func
  35         retq
  36
  37         .globl  _main
  38         .align  4, 0x90
  39 _main:
  40         retq
  41
  42 # Check X86_64_RELOC_GOTPCREL handling with a load from an external symbol.
  43 # Validate both the reference to the GOT entry, and also the content of the GOT
  44 # entry.
  45 #
  46 # jitlink-check: decode_operand(test_gotld, 4) = got_addr(macho_reloc.o, external_data) - next_pc(test_gotld)
  47 # jitlink-check: *{8}(got_addr(macho_reloc.o, external_data)) = external_data
  48         .globl  test_gotld
  49         .align  4, 0x90
  50 test_gotld:
  51         movq    external_data@GOTPCREL(%rip), %rax
  52         retq
  53
  54
  55 # Check X86_64_RELOC_GOTPCREL handling with cmp instructions, which have
  56 # negative addends.
  57 #
  58 # jitlink-check: decode_operand(test_gotcmpq, 3) = got_addr(macho_reloc.o, external_data) - next_pc(test_gotcmpq)
  59         .globl  test_gotcmpq
  60         .align  4, 0x90
  61 test_gotcmpq:
  62         cmpq    $0, external_data@GOTPCREL(%rip)
  63         retq
  64
  65 # Check that calls to external functions trigger the generation of stubs and GOT
  66 # entries.
  67 #
  68 # jitlink-check: decode_operand(test_external_call, 0) = stub_addr(macho_reloc.o, external_func) - next_pc(test_external_call)
  69 # jitlink-check: *{8}(got_addr(macho_reloc.o, external_func)) = external_func
  70         .globl  test_external_call
  71         .align  4, 0x90
  72 test_external_call:
  73         callq   external_func
  74         retq
  75
  76 # Check signed relocation handling:
  77 #
  78 # X86_64_RELOC_SIGNED / Extern -- movq address of linker global
  79 # X86_64_RELOC_SIGNED1 / Extern -- movb immediate byte to linker global
  80 # X86_64_RELOC_SIGNED2 / Extern -- movw immediate word to linker global
  81 # X86_64_RELOC_SIGNED4 / Extern -- movl immediate long to linker global
  82 #
  83 # X86_64_RELOC_SIGNED / Anon -- movq address of linker private into register
  84 # X86_64_RELOC_SIGNED1 / Anon -- movb immediate byte to linker private
  85 # X86_64_RELOC_SIGNED2 / Anon -- movw immediate word to linker private
  86 # X86_64_RELOC_SIGNED4 / Anon -- movl immediate long to linker private
  87 signed_reloc_checks:
  88         .globl signed
  89 # jitlink-check: decode_operand(signed, 4) = named_data - next_pc(signed)
  90 signed:
  91         movq named_data(%rip), %rax
  92
  93         .globl signed1
  94 # jitlink-check: decode_operand(signed1, 3) = named_data - next_pc(signed1)
  95 signed1:
  96         movb $0xAA, named_data(%rip)
  97
  98         .globl signed2
  99 # jitlink-check: decode_operand(signed2, 3) = named_data - next_pc(signed2)
 100 signed2:
 101         movw $0xAAAA, named_data(%rip)
 102
 103         .globl signed4
 104 # jitlink-check: decode_operand(signed4, 3) = named_data - next_pc(signed4)
 105 signed4:
 106         movl $0xAAAAAAAA, named_data(%rip)
 107
 108         .globl signedanon
 109 # jitlink-check: decode_operand(signedanon, 4) = \
 110 # jitlink-check:     section_addr(macho_reloc.o, __DATA,__data) - next_pc(signedanon)
 111 signedanon:
 112         movq Lanon_data(%rip), %rax
 113
 114         .globl signed1anon
 115 # jitlink-check: decode_operand(signed1anon, 3) = \
 116 # jitlink-check:     section_addr(macho_reloc.o, __DATA,__data) - next_pc(signed1anon)
 117 signed1anon:
 118         movb $0xAA, Lanon_data(%rip)
 119
 120         .globl signed2anon
 121 # jitlink-check: decode_operand(signed2anon, 3) = \
 122 # jitlink-check:     section_addr(macho_reloc.o, __DATA,__data) - next_pc(signed2anon)
 123 signed2anon:
 124         movw $0xAAAA, Lanon_data(%rip)
 125
 126         .globl signed4anon
 127 # jitlink-check: decode_operand(signed4anon, 3) = \
 128 # jitlink-check:     section_addr(macho_reloc.o, __DATA,__data) - next_pc(signed4anon)
 129 signed4anon:
 130         movl $0xAAAAAAAA, Lanon_data(%rip)
 131
 132
 133
 134         .section        __DATA,__data
 135
 136 # Storage target for non-extern X86_64_RELOC_SIGNED_(1/2/4) relocs.
 137         .p2align  3
 138 Lanon_data:
 139         .quad   0x1111111111111111
 140
 141 # Check X86_64_RELOC_SUBTRACTOR Quad/Long in anonymous storage with anonymous
 142 # minuend: "LA: .quad LA - B + C". The anonymous subtrahend form
 143 # "LA: .quad B - LA + C" is not tested as subtrahends are not permitted to be
 144 # anonymous.
 145 #
 146 # Note: +8 offset in expression below to accounts for sizeof(Lanon_data).
 147 # jitlink-check: *{8}(section_addr(macho_reloc.o, __DATA,__data) + 8) = \
 148 # jitlink-check:     (section_addr(macho_reloc.o, __DATA,__data) + 8) - named_data - 2
 149         .p2align  3
 150 Lanon_minuend_quad:
 151         .quad Lanon_minuend_quad - named_data - 2
 152
 153 # Note: +16 offset in expression below to accounts for sizeof(Lanon_data) + sizeof(Lanon_minuend_long).
 154 # jitlink-check: *{4}(section_addr(macho_reloc.o, __DATA,__data) + 16) = \
 155 # jitlink-check:     ((section_addr(macho_reloc.o, __DATA,__data) + 16) - named_data - 2)[31:0]
 156         .p2align  2
 157 Lanon_minuend_long:
 158         .long Lanon_minuend_long - named_data - 2
 159
 160 # Named quad storage target (first named atom in __data).
 161         .globl named_data
 162         .p2align  3
 163 named_data:
 164         .quad   0x2222222222222222
 165
 166 # An alt-entry point for named_data
 167         .globl named_data_alt_entry
 168         .p2align  3
 169         .alt_entry named_data_alt_entry
 170 named_data_alt_entry:
 171         .quad   0
 172
 173 # Check X86_64_RELOC_UNSIGNED / quad / extern handling by putting the address of
 174 # a local named function into a quad symbol.
 175 #
 176 # jitlink-check: *{8}named_func_addr_quad = named_func
 177         .globl  named_func_addr_quad
 178         .p2align  3
 179 named_func_addr_quad:
 180         .quad   named_func
 181
 182 # Check X86_64_RELOC_UNSIGNED / long / extern handling by putting the address of
 183 # an external function (defined to reside in the low 4Gb) into a long symbol.
 184 #
 185 # jitlink-check: *{4}named_func_addr_long = external_func
 186         .globl  named_func_addr_long
 187         .p2align  2
 188 named_func_addr_long:
 189         .long   external_func
 190
 191 # Check X86_64_RELOC_UNSIGNED / quad / non-extern handling by putting the
 192 # address of a local anonymous function into a quad symbol.
 193 #
 194 # jitlink-check: *{8}anon_func_addr_quad = section_addr(macho_reloc.o, __TEXT,__text)
 195         .globl  anon_func_addr_quad
 196         .p2align  3
 197 anon_func_addr_quad:
 198         .quad   Lanon_func
 199
 200 # X86_64_RELOC_SUBTRACTOR Quad/Long in named storage with anonymous minuend
 201 #
 202 # jitlink-check: *{8}anon_minuend_quad1 = \
 203 # jitlink-check:     section_addr(macho_reloc.o, __DATA,__data) - anon_minuend_quad1 - 2
 204 # Only the form "B: .quad LA - B + C" is tested. The form "B: .quad B - LA + C" is
 205 # invalid because the subtrahend can not be local.
 206         .globl  anon_minuend_quad1
 207         .p2align  3
 208 anon_minuend_quad1:
 209         .quad Lanon_data - anon_minuend_quad1 - 2
 210
 211 # jitlink-check: *{4}anon_minuend_long1 = \
 212 # jitlink-check:     (section_addr(macho_reloc.o, __DATA,__data) - anon_minuend_long1 - 2)[31:0]
 213         .globl  anon_minuend_long1
 214         .p2align  2
 215 anon_minuend_long1:
 216         .long Lanon_data - anon_minuend_long1 - 2
 217
 218 # Check X86_64_RELOC_SUBTRACTOR Quad/Long in named storage with minuend and subtrahend.
 219 # Both forms "A: .quad A - B + C" and "A: .quad B - A + C" are tested.
 220 #
 221 # Check "A: .quad B - A + C".
 222 # jitlink-check: *{8}subtrahend_quad2 = (named_data - subtrahend_quad2 - 2)
 223         .globl  subtrahend_quad2
 224         .p2align  3
 225 subtrahend_quad2:
 226         .quad named_data - subtrahend_quad2 - 2
 227
 228 # Check "A: .long B - A + C".
 229 # jitlink-check: *{4}subtrahend_long2 = (named_data - subtrahend_long2 - 2)[31:0]
 230         .globl  subtrahend_long2
 231         .p2align  2
 232 subtrahend_long2:
 233         .long named_data - subtrahend_long2 - 2
 234
 235 # Check "A: .quad A - B + C".
 236 # jitlink-check: *{8}minuend_quad3 = (minuend_quad3 - named_data - 2)
 237         .globl  minuend_quad3
 238         .p2align  3
 239 minuend_quad3:
 240         .quad minuend_quad3 - named_data - 2
 241
 242 # Check "A: .long B - A + C".
 243 # jitlink-check: *{4}minuend_long3 = (minuend_long3 - named_data - 2)[31:0]
 244         .globl  minuend_long3
 245         .p2align  2
 246 minuend_long3:
 247         .long minuend_long3 - named_data - 2
 248
 249 # Check X86_64_RELOC_SUBTRACTOR handling for exprs of the form
 250 # "A: .quad/long B - C + D", where 'B' or 'C' is at a fixed offset from 'A'
 251 # (i.e. is part of an alt_entry chain that includes 'A').
 252 #
 253 # Check "A: .long B - C + D" where 'B' is an alt_entry for 'A'.
 254 # jitlink-check: *{4}subtractor_with_alt_entry_minuend_long = (subtractor_with_alt_entry_minuend_long_B - named_data - 2)[31:0]
 255         .globl  subtractor_with_alt_entry_minuend_long
 256         .p2align  2
 257 subtractor_with_alt_entry_minuend_long:
 258         .long subtractor_with_alt_entry_minuend_long_B - named_data - 2
 259
 260         .globl  subtractor_with_alt_entry_minuend_long_B
 261         .p2align  2
 262         .alt_entry subtractor_with_alt_entry_minuend_long_B
 263 subtractor_with_alt_entry_minuend_long_B:
 264         .long 0
 265
 266 # Check "A: .quad B - C + D" where 'B' is an alt_entry for 'A'.
 267 # jitlink-check: *{8}subtractor_with_alt_entry_minuend_quad = (subtractor_with_alt_entry_minuend_quad_B - named_data - 2)
 268         .globl  subtractor_with_alt_entry_minuend_quad
 269         .p2align  3
 270 subtractor_with_alt_entry_minuend_quad:
 271         .quad subtractor_with_alt_entry_minuend_quad_B - named_data - 2
 272
 273         .globl  subtractor_with_alt_entry_minuend_quad_B
 274         .p2align  3
 275         .alt_entry subtractor_with_alt_entry_minuend_quad_B
 276 subtractor_with_alt_entry_minuend_quad_B:
 277         .quad 0
 278
 279 # Check "A: .long B - C + D" where 'C' is an alt_entry for 'A'.
 280 # jitlink-check: *{4}subtractor_with_alt_entry_subtrahend_long = (named_data - subtractor_with_alt_entry_subtrahend_long_B - 2)[31:0]
 281         .globl  subtractor_with_alt_entry_subtrahend_long
 282         .p2align  2
 283 subtractor_with_alt_entry_subtrahend_long:
 284         .long named_data - subtractor_with_alt_entry_subtrahend_long_B - 2
 285
 286         .globl  subtractor_with_alt_entry_subtrahend_long_B
 287         .p2align  2
 288         .alt_entry subtractor_with_alt_entry_subtrahend_long_B
 289 subtractor_with_alt_entry_subtrahend_long_B:
 290         .long 0
 291
 292 # Check "A: .quad B - C + D" where 'B' is an alt_entry for 'A'.
 293 # jitlink-check: *{8}subtractor_with_alt_entry_subtrahend_quad = (named_data - subtractor_with_alt_entry_subtrahend_quad_B - 2)
 294         .globl  subtractor_with_alt_entry_subtrahend_quad
 295         .p2align  3
 296 subtractor_with_alt_entry_subtrahend_quad:
 297         .quad named_data - subtractor_with_alt_entry_subtrahend_quad_B - 2
 298
 299         .globl  subtractor_with_alt_entry_subtrahend_quad_B
 300         .p2align  3
 301         .alt_entry subtractor_with_alt_entry_subtrahend_quad_B
 302 subtractor_with_alt_entry_subtrahend_quad_B:
 303         .quad 0
 304
 305 # Check X86_64_RELOC_GOT handling.
 306 # X86_64_RELOC_GOT is the data-section counterpart to X86_64_RELOC_GOTLD. It is
 307 # handled exactly the same way, including having an implicit PC-rel offset of -4
 308 # (despite this not making sense in a data section, and requiring an explicit
 309 # +4 addend to cancel it out and get the correct result).
 310 #
 311 # jitlink-check: *{4}test_got = (got_addr(macho_reloc.o, external_data) - test_got)[31:0]
 312         .globl test_got
 313         .p2align  2
 314 test_got:
 315         .long   external_data@GOTPCREL + 4
 316
 317 # Check that unreferenced atoms in no-dead-strip sections are not dead stripped.
 318 # We need to use a local symbol for this as any named symbol will end up in the
 319 # ORC responsibility set, which is automatically marked live and would couse
 320 # spurious passes.
 321 #
 322 # jitlink-check: *{8}section_addr(macho_reloc.o, __DATA,__nds_test_sect) = 0
 323         .section        __DATA,__nds_test_sect,regular,no_dead_strip
 324         .quad 0
 325
 326 # Check that unreferenced local symbols that have been marked no-dead-strip are
 327 # not dead-striped.
 328 #
 329 # jitlink-check: *{8}section_addr(macho_reloc.o, __DATA,__nds_test_nlst) = 0
 330         .section       __DATA,__nds_test_nlst,regular
 331         .no_dead_strip no_dead_strip_test_symbol
 332 no_dead_strip_test_symbol:
 333         .quad 0
 334
 335 # Check that explicit zero-fill symbols are supported
 336 # jitlink-check: *{8}zero_fill_test = 0
 337         .globl zero_fill_test
 338 .zerofill __DATA,__zero_fill_test,zero_fill_test,8,3
 339
 340 # Check that section alignments are respected.
 341 # We test this by introducing two segments with alignment 8, each containing one
 342 # byte of data. We require both symbols to have an aligned address.
 343 #
 344 # jitlink-check: section_alignment_check1[2:0] = 0
 345 # jitlink-check: section_alignment_check2[2:0] = 0
 346         .section        __DATA,__sec_align_chk1
 347         .p2align 3
 348
 349         .globl section_alignment_check1
 350 section_alignment_check1:
 351         .byte 0
 352
 353         .section        __DATA,__sec_align_chk2
 354         .p2align 3
 355
 356         .globl section_alignment_check2
 357 section_alignment_check2:
 358         .byte 0
 359
 360 .subsections_via_symbols