1 /** 2 * Compiler implementation of the 3 * $(LINK2 http://www.dlang.org, D programming language). 4 * 5 * Copyright: Copyright (C) 2009-2020 by The D Language Foundation, All Rights Reserved 6 * Authors: $(LINK2 http://www.digitalmars.com, Walter Bright) 7 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) 8 * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/backend/machobj.d, backend/machobj.d) 9 */ 10 11 module dmd.backend.machobj; 12 13 version (SCPP) 14 version = COMPILE; 15 version (MARS) 16 version = COMPILE; 17 18 version (COMPILE) 19 { 20 21 import core.stdc.ctype; 22 import core.stdc.stdint; 23 import core.stdc.stdio; 24 import core.stdc.stdlib; 25 import core.stdc.string; 26 27 import dmd.backend.cc; 28 import dmd.backend.cdef; 29 import dmd.backend.code; 30 import dmd.backend.code_x86; 31 import dmd.backend.mem; 32 import dmd.backend.aarray; 33 import dmd.backend.dlist; 34 import dmd.backend.el; 35 import dmd.backend.global; 36 import dmd.backend.obj; 37 import dmd.backend.oper; 38 import dmd.backend.outbuf; 39 import dmd.backend.ty; 40 import dmd.backend.type; 41 42 extern (C++): 43 44 nothrow: 45 46 alias _compare_fp_t = extern(C) nothrow int function(const void*, const void*); 47 extern(C) void qsort(void* base, size_t nmemb, size_t size, _compare_fp_t compar); 48 49 static if (MACHOBJ) 50 { 51 52 import dmd.backend.dwarf; 53 import dmd.backend.mach; 54 55 alias nlist = dmd.backend.mach.nlist; // avoid conflict with dmd.backend.dlist.nlist 56 57 /**************************************** 58 * Sort the relocation entry buffer. 59 * put before nothrow because qsort was not marked nothrow until version 2.086 60 */ 61 62 extern (C) { 63 private int rel_fp(scope const(void*) e1, scope const(void*) e2) 64 { Relocation *r1 = cast(Relocation *)e1; 65 Relocation *r2 = cast(Relocation *)e2; 66 67 return cast(int)(r1.offset - r2.offset); 68 } 69 } 70 71 void mach_relsort(Outbuffer *buf) 72 { 73 qsort(buf.buf, buf.length() / Relocation.sizeof, Relocation.sizeof, &rel_fp); 74 } 75 76 // for x86_64 77 enum 78 { 79 X86_64_RELOC_UNSIGNED = 0, 80 X86_64_RELOC_SIGNED = 1, 81 X86_64_RELOC_BRANCH = 2, 82 X86_64_RELOC_GOT_LOAD = 3, 83 X86_64_RELOC_GOT = 4, 84 X86_64_RELOC_SUBTRACTOR = 5, 85 X86_64_RELOC_SIGNED_1 = 6, 86 X86_64_RELOC_SIGNED_2 = 7, 87 X86_64_RELOC_SIGNED_4 = 8, 88 X86_64_RELOC_TLV = 9, // for thread local variables 89 } 90 91 private __gshared Outbuffer *fobjbuf; 92 93 enum DEST_LEN = (IDMAX + IDOHD + 1); 94 char *obj_mangle2(Symbol *s,char *dest); 95 96 extern __gshared int except_table_seg; // segment of __gcc_except_tab 97 extern __gshared int eh_frame_seg; // segment of __eh_frame 98 99 100 /****************************************** 101 */ 102 103 /// Returns: a reference to the global offset table 104 Symbol* Obj_getGOTsym() 105 { 106 __gshared Symbol *GOTsym; 107 if (!GOTsym) 108 { 109 GOTsym = symbol_name("_GLOBAL_OFFSET_TABLE_",SCglobal,tspvoid); 110 } 111 return GOTsym; 112 } 113 114 void Obj_refGOTsym() 115 { 116 assert(0); 117 } 118 119 // The object file is built is several separate pieces 120 121 122 // String Table - String table for all other names 123 private __gshared Outbuffer *symtab_strings; 124 125 // Section Headers 126 __gshared Outbuffer *SECbuf; // Buffer to build section table in 127 section* SecHdrTab() { return cast(section *)SECbuf.buf; } 128 section_64* SecHdrTab64() { return cast(section_64 *)SECbuf.buf; } 129 130 __gshared 131 { 132 133 // The relocation for text and data seems to get lost. 134 // Try matching the order gcc output them 135 // This means defining the sections and then removing them if they are 136 // not used. 137 private int section_cnt; // Number of sections in table 138 enum SEC_TAB_INIT = 16; // Initial number of sections in buffer 139 enum SEC_TAB_INC = 4; // Number of sections to increment buffer by 140 141 enum SYM_TAB_INIT = 100; // Initial number of symbol entries in buffer 142 enum SYM_TAB_INC = 50; // Number of symbols to increment buffer by 143 144 /* Three symbol tables, because the different types of symbols 145 * are grouped into 3 different types (and a 4th for comdef's). 146 */ 147 148 private Outbuffer *local_symbuf; 149 private Outbuffer *public_symbuf; 150 private Outbuffer *extern_symbuf; 151 } 152 153 private void reset_symbols(Outbuffer *buf) 154 { 155 Symbol **p = cast(Symbol **)buf.buf; 156 const size_t n = buf.length() / (Symbol *).sizeof; 157 for (size_t i = 0; i < n; ++i) 158 symbol_reset(p[i]); 159 } 160 161 __gshared 162 { 163 164 struct Comdef { Symbol *sym; targ_size_t size; int count; } 165 private Outbuffer *comdef_symbuf; // Comdef's are stored here 166 167 private Outbuffer *indirectsymbuf1; // indirect symbol table of Symbol*'s 168 private int jumpTableSeg; // segment index for __jump_table 169 170 private Outbuffer *indirectsymbuf2; // indirect symbol table of Symbol*'s 171 private int pointersSeg; // segment index for __pointers 172 173 /* If an Obj_external_def() happens, set this to the string index, 174 * to be added last to the symbol table. 175 * Obviously, there can be only one. 176 */ 177 private IDXSTR extdef; 178 } 179 180 static if (0) 181 { 182 enum 183 { 184 STI_FILE = 1, // Where file symbol table entry is 185 STI_TEXT = 2, 186 STI_DATA = 3, 187 STI_BSS = 4, 188 STI_GCC = 5, // Where "gcc2_compiled" symbol is */ 189 STI_RODAT = 6, // Symbol for readonly data 190 STI_COM = 8, 191 } 192 } 193 194 // Each compiler segment is a section 195 // Predefined compiler segments CODE,DATA,CDATA,UDATA map to indexes 196 // into SegData[] 197 // New compiler segments are added to end. 198 199 /****************************** 200 * Returns !=0 if this segment is a code segment. 201 */ 202 203 int seg_data_isCode(const ref seg_data sd) 204 { 205 // The codegen assumes that code.data references are indirect, 206 // but when CDATA is treated as code reftoident will emit a direct 207 // relocation. 208 if (&sd == SegData[CDATA]) 209 return false; 210 211 if (I64) 212 { 213 //printf("SDshtidx = %d, x%x\n", SDshtidx, SecHdrTab64[sd.SDshtidx].flags); 214 return strcmp(SecHdrTab64[sd.SDshtidx].segname.ptr, "__TEXT") == 0; 215 } 216 else 217 { 218 //printf("SDshtidx = %d, x%x\n", SDshtidx, SecHdrTab[sd.SDshtidx].flags); 219 return strcmp(SecHdrTab[sd.SDshtidx].segname.ptr, "__TEXT") == 0; 220 } 221 } 222 223 224 __gshared 225 { 226 seg_data **SegData; 227 int seg_count; 228 int seg_max; 229 230 /** 231 * Section index for the __thread_vars/__tls_data section. 232 * 233 * This section is used for the variable symbol for TLS variables. 234 */ 235 int seg_tlsseg = UNKNOWN; 236 237 /** 238 * Section index for the __thread_bss section. 239 * 240 * This section is used for the data symbol ($tlv$init) for TLS variables 241 * without an initializer. 242 */ 243 int seg_tlsseg_bss = UNKNOWN; 244 245 /** 246 * Section index for the __thread_data section. 247 * 248 * This section is used for the data symbol ($tlv$init) for TLS variables 249 * with an initializer. 250 */ 251 int seg_tlsseg_data = UNKNOWN; 252 } 253 254 /******************************************************* 255 * Because the Mach-O relocations cannot be computed until after 256 * all the segments are written out, and we need more information 257 * than the Mach-O relocations provide, make our own relocation 258 * type. Later, translate to Mach-O relocation structure. 259 */ 260 261 enum 262 { 263 RELaddr = 0, // straight address 264 RELrel = 1, // relative to location to be fixed up 265 } 266 267 struct Relocation 268 { // Relocations are attached to the struct seg_data they refer to 269 targ_size_t offset; // location in segment to be fixed up 270 Symbol *funcsym; // function in which offset lies, if any 271 Symbol *targsym; // if !=null, then location is to be fixed up 272 // to address of this symbol 273 uint targseg; // if !=0, then location is to be fixed up 274 // to address of start of this segment 275 ubyte rtype; // RELxxxx 276 ubyte flag; // 1: emit SUBTRACTOR/UNSIGNED pair 277 short val; // 0, -1, -2, -4 278 } 279 280 281 /******************************* 282 * Output a string into a string table 283 * Input: 284 * strtab = string table for entry 285 * str = string to add 286 * 287 * Returns index into the specified string table. 288 */ 289 290 IDXSTR Obj_addstr(Outbuffer *strtab, const(char)* str) 291 { 292 //printf("Obj_addstr(strtab = %p str = '%s')\n",strtab,str); 293 IDXSTR idx = cast(IDXSTR)strtab.length(); // remember starting offset 294 strtab.writeString(str); 295 //printf("\tidx %d, new size %d\n",idx,strtab.length()); 296 return idx; 297 } 298 299 /******************************* 300 * Output a mangled string into the symbol string table 301 * Input: 302 * str = string to add 303 * 304 * Returns index into the table. 305 */ 306 307 private IDXSTR elf_addmangled(Symbol *s) 308 { 309 //printf("elf_addmangled(%s)\n", s.Sident); 310 char[DEST_LEN] dest = void; 311 char *destr; 312 const(char)* name; 313 IDXSTR namidx; 314 315 namidx = cast(IDXSTR)symtab_strings.length(); 316 destr = obj_mangle2(s, dest.ptr); 317 name = destr; 318 if (CPP && name[0] == '_' && name[1] == '_') 319 { 320 if (strncmp(name,"__ct__",6) == 0) 321 name += 4; 322 static if (0) 323 { 324 switch(name[2]) 325 { 326 case 'c': 327 if (strncmp(name,"__ct__",6) == 0) 328 name += 4; 329 break; 330 case 'd': 331 if (strcmp(name,"__dl__FvP") == 0) 332 name = "__builtin_delete"; 333 break; 334 case 'v': 335 //if (strcmp(name,"__vec_delete__FvPiUIPi") == 0) 336 //name = "__builtin_vec_del"; 337 //else 338 //if (strcmp(name,"__vn__FPUI") == 0) 339 //name = "__builtin_vec_new"; 340 break; 341 case 'n': 342 if (strcmp(name,"__nw__FPUI") == 0) 343 name = "__builtin_new"; 344 break; 345 346 default: 347 break; 348 } 349 } 350 } 351 else if (tyfunc(s.ty()) && s.Sfunc && s.Sfunc.Fredirect) 352 name = s.Sfunc.Fredirect; 353 symtab_strings.writeString(name); 354 if (destr != dest.ptr) // if we resized result 355 mem_free(destr); 356 //dbg_printf("\telf_addmagled symtab_strings %s namidx %d len %d size %d\n",name, namidx,len,symtab_strings.length()); 357 return namidx; 358 } 359 360 /************************** 361 * Ouput read only data and generate a symbol for it. 362 * 363 */ 364 365 Symbol * Obj_sym_cdata(tym_t ty,char *p,int len) 366 { 367 Symbol *s; 368 369 static if (0) 370 { 371 if (I64) 372 { 373 alignOffset(DATA, tysize(ty)); 374 s = symboldata(Offset(DATA), ty); 375 SegData[DATA].SDbuf.write(p,len); 376 s.Sseg = DATA; 377 s.Soffset = Offset(DATA); // Remember its offset into DATA section 378 Offset(DATA) += len; 379 380 s.Sfl = /*(config.flags3 & CFG3pic) ? FLgotoff :*/ FLextern; 381 return s; 382 } 383 } 384 //printf("Obj_sym_cdata(ty = %x, p = %x, len = %d, Offset(CDATA) = %x)\n", ty, p, len, Offset(CDATA)); 385 alignOffset(CDATA, tysize(ty)); 386 s = symboldata(Offset(CDATA), ty); 387 s.Sseg = CDATA; 388 //Obj_pubdef(CDATA, s, Offset(CDATA)); 389 Obj_bytes(CDATA, Offset(CDATA), len, p); 390 391 s.Sfl = /*(config.flags3 & CFG3pic) ? FLgotoff :*/ FLextern; 392 return s; 393 } 394 395 /************************** 396 * Ouput read only data for data 397 * 398 */ 399 400 int Obj_data_readonly(char *p, int len, int *pseg) 401 { 402 int oldoff = cast(int)Offset(CDATA); 403 SegData[CDATA].SDbuf.reserve(len); 404 SegData[CDATA].SDbuf.writen(p,len); 405 Offset(CDATA) += len; 406 *pseg = CDATA; 407 return oldoff; 408 } 409 410 int Obj_data_readonly(char *p, int len) 411 { 412 int pseg; 413 414 return Obj_data_readonly(p, len, &pseg); 415 } 416 417 /***************************** 418 * Get segment for readonly string literals. 419 * The linker will pool strings in this section. 420 * Params: 421 * sz = number of bytes per character (1, 2, or 4) 422 * Returns: 423 * segment index 424 */ 425 int Obj_string_literal_segment(uint sz) 426 { 427 if (sz == 1) 428 { 429 return Obj_getsegment("__cstring", "__TEXT", 0, S_CSTRING_LITERALS); 430 } 431 return CDATA; // no special handling for other wstring, dstring; use __const 432 } 433 434 /****************************** 435 * Perform initialization that applies to all .o output files. 436 * Called before any other obj_xxx routines 437 */ 438 439 Obj Obj_init(Outbuffer *objbuf, const(char)* filename, const(char)* csegname) 440 { 441 //printf("Obj_init()\n"); 442 Obj obj = cast(Obj)mem_calloc(__traits(classInstanceSize, Obj)); 443 444 cseg = CODE; 445 fobjbuf = objbuf; 446 447 seg_tlsseg = UNKNOWN; 448 seg_tlsseg_bss = UNKNOWN; 449 seg_tlsseg_data = UNKNOWN; 450 451 // Initialize buffers 452 453 if (symtab_strings) 454 symtab_strings.setsize(1); 455 else 456 { 457 symtab_strings = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 458 assert(symtab_strings); 459 symtab_strings.reserve(2048); 460 symtab_strings.writeByte(0); 461 } 462 463 if (!local_symbuf) 464 { 465 local_symbuf = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 466 assert(local_symbuf); 467 local_symbuf.reserve((Symbol *).sizeof * SYM_TAB_INIT); 468 } 469 local_symbuf.reset(); 470 471 if (public_symbuf) 472 { 473 reset_symbols(public_symbuf); 474 public_symbuf.reset(); 475 } 476 else 477 { 478 public_symbuf = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 479 assert(public_symbuf); 480 public_symbuf.reserve((Symbol *).sizeof * SYM_TAB_INIT); 481 } 482 483 if (extern_symbuf) 484 { 485 reset_symbols(extern_symbuf); 486 extern_symbuf.reset(); 487 } 488 else 489 { 490 extern_symbuf = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 491 assert(extern_symbuf); 492 extern_symbuf.reserve((Symbol *).sizeof * SYM_TAB_INIT); 493 } 494 495 if (!comdef_symbuf) 496 { 497 comdef_symbuf = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 498 assert(comdef_symbuf); 499 comdef_symbuf.reserve((Symbol *).sizeof * SYM_TAB_INIT); 500 } 501 comdef_symbuf.reset(); 502 503 extdef = 0; 504 505 if (indirectsymbuf1) 506 indirectsymbuf1.reset(); 507 jumpTableSeg = 0; 508 509 if (indirectsymbuf2) 510 indirectsymbuf2.reset(); 511 pointersSeg = 0; 512 513 // Initialize segments for CODE, DATA, UDATA and CDATA 514 size_t struct_section_size = I64 ? section_64.sizeof : section.sizeof; 515 if (SECbuf) 516 { 517 SECbuf.setsize(cast(uint)struct_section_size); 518 } 519 else 520 { 521 SECbuf = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 522 assert(SECbuf); 523 SECbuf.reserve(cast(uint)(SEC_TAB_INIT * struct_section_size)); 524 // Ignore the first section - section numbers start at 1 525 SECbuf.writezeros(cast(uint)struct_section_size); 526 } 527 section_cnt = 1; 528 529 seg_count = 0; 530 int align_ = I64 ? 4 : 2; // align to 16 bytes for floating point 531 Obj_getsegment("__text", "__TEXT", 2, S_REGULAR | S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS); 532 Obj_getsegment("__data", "__DATA", align_, S_REGULAR); // DATA 533 Obj_getsegment("__const", "__TEXT", 2, S_REGULAR); // CDATA 534 Obj_getsegment("__bss", "__DATA", 4, S_ZEROFILL); // UDATA 535 Obj_getsegment("__const", "__DATA", align_, S_REGULAR); // CDATAREL 536 537 dwarf_initfile(filename); 538 return obj; 539 } 540 541 /************************** 542 * Initialize the start of object output for this particular .o file. 543 * 544 * Input: 545 * filename: Name of source file 546 * csegname: User specified default code segment name 547 */ 548 549 void Obj_initfile(const(char)* filename, const(char)* csegname, const(char)* modname) 550 { 551 //dbg_printf("Obj_initfile(filename = %s, modname = %s)\n",filename,modname); 552 version (SCPP) 553 { 554 if (csegname && *csegname && strcmp(csegname,".text")) 555 { // Define new section and make it the default for cseg segment 556 // NOTE: cseg is initialized to CODE 557 IDXSEC newsecidx; 558 Elf32_Shdr *newtextsec; 559 IDXSYM newsymidx; 560 assert(!I64); // fix later 561 SegData[cseg].SDshtidx = newsecidx = 562 elf_newsection(csegname,0,SHT_PROGDEF,SHF_ALLOC|SHF_EXECINSTR); 563 newtextsec = &SecHdrTab[newsecidx]; 564 newtextsec.sh_addralign = 4; 565 SegData[cseg].SDsymidx = 566 elf_addsym(0, 0, 0, STT_SECTION, STB_LOCAL, newsecidx); 567 } 568 } 569 if (config.fulltypes) 570 dwarf_initmodule(filename, modname); 571 } 572 573 /************************************ 574 * Patch pseg/offset by adding in the vmaddr difference from 575 * pseg/offset to start of seg. 576 */ 577 578 int32_t *patchAddr(int seg, targ_size_t offset) 579 { 580 return cast(int32_t *)(fobjbuf.buf + SecHdrTab[SegData[seg].SDshtidx].offset + offset); 581 } 582 583 int32_t *patchAddr64(int seg, targ_size_t offset) 584 { 585 return cast(int32_t *)(fobjbuf.buf + SecHdrTab64[SegData[seg].SDshtidx].offset + offset); 586 } 587 588 void patch(seg_data *pseg, targ_size_t offset, int seg, targ_size_t value) 589 { 590 //printf("patch(offset = x%04x, seg = %d, value = x%llx)\n", (uint)offset, seg, value); 591 if (I64) 592 { 593 int32_t *p = cast(int32_t *)(fobjbuf.buf + SecHdrTab64[pseg.SDshtidx].offset + offset); 594 static if (0) 595 { 596 printf("\taddr1 = x%llx\n\taddr2 = x%llx\n\t*p = x%llx\n\tdelta = x%llx\n", 597 SecHdrTab64[pseg.SDshtidx].addr, 598 SecHdrTab64[SegData[seg].SDshtidx].addr, 599 *p, 600 SecHdrTab64[SegData[seg].SDshtidx].addr - 601 (SecHdrTab64[pseg.SDshtidx].addr + offset)); 602 } 603 *p += SecHdrTab64[SegData[seg].SDshtidx].addr - 604 (SecHdrTab64[pseg.SDshtidx].addr - value); 605 } 606 else 607 { 608 int32_t *p = cast(int32_t *)(fobjbuf.buf + SecHdrTab[pseg.SDshtidx].offset + offset); 609 static if (0) 610 { 611 printf("\taddr1 = x%x\n\taddr2 = x%x\n\t*p = x%x\n\tdelta = x%x\n", 612 SecHdrTab[pseg.SDshtidx].addr, 613 SecHdrTab[SegData[seg].SDshtidx].addr, 614 *p, 615 SecHdrTab[SegData[seg].SDshtidx].addr - 616 (SecHdrTab[pseg.SDshtidx].addr + offset)); 617 } 618 *p += SecHdrTab[SegData[seg].SDshtidx].addr - 619 (SecHdrTab[pseg.SDshtidx].addr - value); 620 } 621 } 622 623 /*************************** 624 * Number symbols so they are 625 * ordered as locals, public and then extern/comdef 626 */ 627 628 void mach_numbersyms() 629 { 630 //printf("mach_numbersyms()\n"); 631 int n = 0; 632 633 int dim; 634 dim = cast(int)(local_symbuf.length() / (Symbol *).sizeof); 635 for (int i = 0; i < dim; i++) 636 { Symbol *s = (cast(Symbol **)local_symbuf.buf)[i]; 637 s.Sxtrnnum = n; 638 n++; 639 } 640 641 dim = cast(int)(public_symbuf.length() / (Symbol *).sizeof); 642 for (int i = 0; i < dim; i++) 643 { Symbol *s = (cast(Symbol **)public_symbuf.buf)[i]; 644 s.Sxtrnnum = n; 645 n++; 646 } 647 648 dim = cast(int)(extern_symbuf.length() / (Symbol *).sizeof); 649 for (int i = 0; i < dim; i++) 650 { Symbol *s = (cast(Symbol **)extern_symbuf.buf)[i]; 651 s.Sxtrnnum = n; 652 n++; 653 } 654 655 dim = cast(int)(comdef_symbuf.length() / Comdef.sizeof); 656 for (int i = 0; i < dim; i++) 657 { Comdef *c = (cast(Comdef *)comdef_symbuf.buf) + i; 658 c.sym.Sxtrnnum = n; 659 n++; 660 } 661 } 662 663 664 /*************************** 665 * Fixup and terminate object file. 666 */ 667 668 void Obj_termfile() 669 { 670 //dbg_printf("Obj_termfile\n"); 671 if (configv.addlinenumbers) 672 { 673 dwarf_termmodule(); 674 } 675 } 676 677 /********************************* 678 * Terminate package. 679 */ 680 681 void Obj_term(const(char)* objfilename) 682 { 683 //printf("Obj_term()\n"); 684 version (SCPP) 685 { 686 if (!errcnt) 687 { 688 outfixlist(); // backpatches 689 } 690 } 691 else 692 { 693 outfixlist(); // backpatches 694 } 695 696 if (configv.addlinenumbers) 697 { 698 dwarf_termfile(); 699 } 700 701 version (SCPP) 702 { 703 if (errcnt) 704 return; 705 } 706 707 /* Write out the object file in the following order: 708 * header 709 * commands 710 * segment_command 711 * { sections } 712 * symtab_command 713 * dysymtab_command 714 * { segment contents } 715 * { relocations } 716 * symbol table 717 * string table 718 * indirect symbol table 719 */ 720 721 uint foffset; 722 uint headersize; 723 uint sizeofcmds; 724 725 // Write out the bytes for the header 726 if (I64) 727 { 728 mach_header_64 header = void; 729 730 header.magic = MH_MAGIC_64; 731 header.cputype = CPU_TYPE_X86_64; 732 header.cpusubtype = CPU_SUBTYPE_I386_ALL; 733 header.filetype = MH_OBJECT; 734 header.ncmds = 3; 735 header.sizeofcmds = cast(uint)(segment_command_64.sizeof + 736 (section_cnt - 1) * section_64.sizeof + 737 symtab_command.sizeof + 738 dysymtab_command.sizeof); 739 header.flags = MH_SUBSECTIONS_VIA_SYMBOLS; 740 header.reserved = 0; 741 fobjbuf.write(&header, header.sizeof); 742 foffset = header.sizeof; // start after header 743 headersize = header.sizeof; 744 sizeofcmds = header.sizeofcmds; 745 746 // Write the actual data later 747 fobjbuf.writezeros(header.sizeofcmds); 748 foffset += header.sizeofcmds; 749 } 750 else 751 { 752 mach_header header = void; 753 754 header.magic = MH_MAGIC; 755 header.cputype = CPU_TYPE_I386; 756 header.cpusubtype = CPU_SUBTYPE_I386_ALL; 757 header.filetype = MH_OBJECT; 758 header.ncmds = 3; 759 header.sizeofcmds = cast(uint)(segment_command.sizeof + 760 (section_cnt - 1) * section.sizeof + 761 symtab_command.sizeof + 762 dysymtab_command.sizeof); 763 header.flags = MH_SUBSECTIONS_VIA_SYMBOLS; 764 fobjbuf.write(&header, header.sizeof); 765 foffset = header.sizeof; // start after header 766 headersize = header.sizeof; 767 sizeofcmds = header.sizeofcmds; 768 769 // Write the actual data later 770 fobjbuf.writezeros(header.sizeofcmds); 771 foffset += header.sizeofcmds; 772 } 773 774 segment_command segment_cmd = void; 775 segment_command_64 segment_cmd64 = void; 776 symtab_command symtab_cmd = void; 777 dysymtab_command dysymtab_cmd = void; 778 779 memset(&segment_cmd, 0, segment_cmd.sizeof); 780 memset(&segment_cmd64, 0, segment_cmd64.sizeof); 781 memset(&symtab_cmd, 0, symtab_cmd.sizeof); 782 memset(&dysymtab_cmd, 0, dysymtab_cmd.sizeof); 783 784 if (I64) 785 { 786 segment_cmd64.cmd = LC_SEGMENT_64; 787 segment_cmd64.cmdsize = cast(uint)(segment_cmd64.sizeof + 788 (section_cnt - 1) * section_64.sizeof); 789 segment_cmd64.nsects = section_cnt - 1; 790 segment_cmd64.maxprot = 7; 791 segment_cmd64.initprot = 7; 792 } 793 else 794 { 795 segment_cmd.cmd = LC_SEGMENT; 796 segment_cmd.cmdsize = cast(uint)(segment_cmd.sizeof + 797 (section_cnt - 1) * section.sizeof); 798 segment_cmd.nsects = section_cnt - 1; 799 segment_cmd.maxprot = 7; 800 segment_cmd.initprot = 7; 801 } 802 803 symtab_cmd.cmd = LC_SYMTAB; 804 symtab_cmd.cmdsize = symtab_cmd.sizeof; 805 806 dysymtab_cmd.cmd = LC_DYSYMTAB; 807 dysymtab_cmd.cmdsize = dysymtab_cmd.sizeof; 808 809 /* If a __pointers section was emitted, need to set the .reserved1 810 * field to the symbol index in the indirect symbol table of the 811 * start of the __pointers symbols. 812 */ 813 if (pointersSeg) 814 { 815 seg_data *pseg = SegData[pointersSeg]; 816 if (I64) 817 { 818 section_64 *psechdr = &SecHdrTab64[pseg.SDshtidx]; // corresponding section 819 psechdr.reserved1 = cast(uint)(indirectsymbuf1 820 ? indirectsymbuf1.length() / (Symbol *).sizeof 821 : 0); 822 } 823 else 824 { 825 section *psechdr = &SecHdrTab[pseg.SDshtidx]; // corresponding section 826 psechdr.reserved1 = cast(uint)(indirectsymbuf1 827 ? indirectsymbuf1.length() / (Symbol *).sizeof 828 : 0); 829 } 830 } 831 832 // Walk through sections determining size and file offsets 833 834 // 835 // First output individual section data associate with program 836 // code and data 837 // 838 foffset = elf_align(I64 ? 8 : 4, foffset); 839 if (I64) 840 segment_cmd64.fileoff = foffset; 841 else 842 segment_cmd.fileoff = foffset; 843 uint vmaddr = 0; 844 845 //printf("Setup offsets and sizes foffset %d\n\tsection_cnt %d, seg_count %d\n",foffset,section_cnt,seg_count); 846 // Zero filled segments go at the end, so go through segments twice 847 for (int i = 0; i < 2; i++) 848 { 849 for (int seg = 1; seg <= seg_count; seg++) 850 { 851 seg_data *pseg = SegData[seg]; 852 if (I64) 853 { 854 section_64 *psechdr = &SecHdrTab64[pseg.SDshtidx]; // corresponding section 855 856 // Do zero-fill the second time through this loop 857 if (i ^ (psechdr.flags == S_ZEROFILL)) 858 continue; 859 860 int align_ = 1 << psechdr._align; 861 while (psechdr._align > 0 && align_ < pseg.SDalignment) 862 { 863 psechdr._align += 1; 864 align_ <<= 1; 865 } 866 foffset = elf_align(align_, foffset); 867 vmaddr = (vmaddr + align_ - 1) & ~(align_ - 1); 868 if (psechdr.flags == S_ZEROFILL) 869 { 870 psechdr.offset = 0; 871 psechdr.size = pseg.SDoffset; // accumulated size 872 } 873 else 874 { 875 psechdr.offset = foffset; 876 psechdr.size = 0; 877 //printf("\tsection name %s,", psechdr.sectname); 878 if (pseg.SDbuf && pseg.SDbuf.length()) 879 { 880 //printf("\tsize %d\n", pseg.SDbuf.length()); 881 psechdr.size = pseg.SDbuf.length(); 882 fobjbuf.write(pseg.SDbuf.buf, cast(uint)psechdr.size); 883 foffset += psechdr.size; 884 } 885 } 886 psechdr.addr = vmaddr; 887 vmaddr += psechdr.size; 888 //printf(" assigned offset %d, size %d\n", foffset, psechdr.sh_size); 889 } 890 else 891 { 892 section *psechdr = &SecHdrTab[pseg.SDshtidx]; // corresponding section 893 894 // Do zero-fill the second time through this loop 895 if (i ^ (psechdr.flags == S_ZEROFILL)) 896 continue; 897 898 int align_ = 1 << psechdr._align; 899 while (psechdr._align > 0 && align_ < pseg.SDalignment) 900 { 901 psechdr._align += 1; 902 align_ <<= 1; 903 } 904 foffset = elf_align(align_, foffset); 905 vmaddr = (vmaddr + align_ - 1) & ~(align_ - 1); 906 if (psechdr.flags == S_ZEROFILL) 907 { 908 psechdr.offset = 0; 909 psechdr.size = cast(uint)pseg.SDoffset; // accumulated size 910 } 911 else 912 { 913 psechdr.offset = foffset; 914 psechdr.size = 0; 915 //printf("\tsection name %s,", psechdr.sectname); 916 if (pseg.SDbuf && pseg.SDbuf.length()) 917 { 918 //printf("\tsize %d\n", pseg.SDbuf.length()); 919 psechdr.size = cast(uint)pseg.SDbuf.length(); 920 fobjbuf.write(pseg.SDbuf.buf, psechdr.size); 921 foffset += psechdr.size; 922 } 923 } 924 psechdr.addr = vmaddr; 925 vmaddr += psechdr.size; 926 //printf(" assigned offset %d, size %d\n", foffset, psechdr.sh_size); 927 } 928 } 929 } 930 931 if (I64) 932 { 933 segment_cmd64.vmsize = vmaddr; 934 segment_cmd64.filesize = foffset - segment_cmd64.fileoff; 935 /* Bugzilla 5331: Apparently having the filesize field greater than the vmsize field is an 936 * error, and is happening sometimes. 937 */ 938 if (segment_cmd64.filesize > vmaddr) 939 segment_cmd64.vmsize = segment_cmd64.filesize; 940 } 941 else 942 { 943 segment_cmd.vmsize = vmaddr; 944 segment_cmd.filesize = foffset - segment_cmd.fileoff; 945 /* Bugzilla 5331: Apparently having the filesize field greater than the vmsize field is an 946 * error, and is happening sometimes. 947 */ 948 if (segment_cmd.filesize > vmaddr) 949 segment_cmd.vmsize = segment_cmd.filesize; 950 } 951 952 // Put out relocation data 953 mach_numbersyms(); 954 for (int seg = 1; seg <= seg_count; seg++) 955 { 956 seg_data *pseg = SegData[seg]; 957 section *psechdr = null; 958 section_64 *psechdr64 = null; 959 if (I64) 960 { 961 psechdr64 = &SecHdrTab64[pseg.SDshtidx]; // corresponding section 962 //printf("psechdr.addr = x%llx\n", psechdr64.addr); 963 } 964 else 965 { 966 psechdr = &SecHdrTab[pseg.SDshtidx]; // corresponding section 967 //printf("psechdr.addr = x%x\n", psechdr.addr); 968 } 969 foffset = elf_align(I64 ? 8 : 4, foffset); 970 uint reloff = foffset; 971 uint nreloc = 0; 972 if (pseg.SDrel) 973 { Relocation *r = cast(Relocation *)pseg.SDrel.buf; 974 Relocation *rend = cast(Relocation *)(pseg.SDrel.buf + pseg.SDrel.length()); 975 for (; r != rend; r++) 976 { Symbol *s = r.targsym; 977 const(char)* rs = r.rtype == RELaddr ? "addr" : "rel"; 978 //printf("%d:x%04llx : tseg %d tsym %s REL%s\n", seg, r.offset, r.targseg, s ? s.Sident.ptr : "0", rs); 979 relocation_info rel; 980 scattered_relocation_info srel; 981 if (s) 982 { 983 //printf("Relocation\n"); 984 //symbol_print(s); 985 if (r.flag == 1) 986 { 987 if (I64) 988 { 989 rel.r_type = X86_64_RELOC_SUBTRACTOR; 990 rel.r_address = cast(int)r.offset; 991 rel.r_symbolnum = r.funcsym.Sxtrnnum; 992 rel.r_pcrel = 0; 993 rel.r_length = 3; 994 rel.r_extern = 1; 995 fobjbuf.write(&rel, rel.sizeof); 996 foffset += (rel).sizeof; 997 ++nreloc; 998 999 rel.r_type = X86_64_RELOC_UNSIGNED; 1000 rel.r_symbolnum = s.Sxtrnnum; 1001 fobjbuf.write(&rel, rel.sizeof); 1002 foffset += rel.sizeof; 1003 ++nreloc; 1004 1005 // patch with fdesym.Soffset - offset 1006 int64_t *p = cast(int64_t *)patchAddr64(seg, r.offset); 1007 *p += r.funcsym.Soffset - r.offset; 1008 continue; 1009 } 1010 else 1011 { 1012 // address = segment + offset 1013 int targ_address = cast(int)(SecHdrTab[SegData[s.Sseg].SDshtidx].addr + s.Soffset); 1014 int fixup_address = cast(int)(psechdr.addr + r.offset); 1015 1016 srel.r_scattered = 1; 1017 srel.r_type = GENERIC_RELOC_LOCAL_SECTDIFF; 1018 srel.r_address = cast(uint)r.offset; 1019 srel.r_pcrel = 0; 1020 srel.r_length = 2; 1021 srel.r_value = targ_address; 1022 fobjbuf.write((&srel)[0 .. 1]); 1023 foffset += srel.sizeof; 1024 ++nreloc; 1025 1026 srel.r_type = GENERIC_RELOC_PAIR; 1027 srel.r_address = 0; 1028 srel.r_value = fixup_address; 1029 fobjbuf.write(&srel, srel.sizeof); 1030 foffset += srel.sizeof; 1031 ++nreloc; 1032 1033 int32_t *p = patchAddr(seg, r.offset); 1034 *p += targ_address - fixup_address; 1035 continue; 1036 } 1037 } 1038 else if (pseg.isCode()) 1039 { 1040 if (I64) 1041 { 1042 rel.r_type = (r.rtype == RELrel) 1043 ? X86_64_RELOC_BRANCH 1044 : X86_64_RELOC_SIGNED; 1045 if (r.val == -1) 1046 rel.r_type = X86_64_RELOC_SIGNED_1; 1047 else if (r.val == -2) 1048 rel.r_type = X86_64_RELOC_SIGNED_2; 1049 if (r.val == -4) 1050 rel.r_type = X86_64_RELOC_SIGNED_4; 1051 1052 if (s.Sclass == SCextern || 1053 s.Sclass == SCcomdef || 1054 s.Sclass == SCcomdat || 1055 s.Sclass == SCglobal) 1056 { 1057 if (I64 && (s.ty() & mTYLINK) == mTYthread && r.rtype == RELaddr) 1058 rel.r_type = X86_64_RELOC_TLV; 1059 else if ((s.Sfl == FLfunc || s.Sfl == FLextern || s.Sclass == SCglobal || s.Sclass == SCcomdat || s.Sclass == SCcomdef) && r.rtype == RELaddr) 1060 { 1061 rel.r_type = X86_64_RELOC_GOT_LOAD; 1062 if (seg == eh_frame_seg || 1063 seg == except_table_seg) 1064 rel.r_type = X86_64_RELOC_GOT; 1065 } 1066 rel.r_address = cast(int)r.offset; 1067 rel.r_symbolnum = s.Sxtrnnum; 1068 rel.r_pcrel = 1; 1069 rel.r_length = 2; 1070 rel.r_extern = 1; 1071 fobjbuf.write(&rel, rel.sizeof); 1072 foffset += rel.sizeof; 1073 nreloc++; 1074 continue; 1075 } 1076 else 1077 { 1078 rel.r_address = cast(int)r.offset; 1079 rel.r_symbolnum = s.Sseg; 1080 rel.r_pcrel = 1; 1081 rel.r_length = 2; 1082 rel.r_extern = 0; 1083 fobjbuf.write(&rel, rel.sizeof); 1084 foffset += rel.sizeof; 1085 nreloc++; 1086 1087 int32_t *p = patchAddr64(seg, r.offset); 1088 // Absolute address; add in addr of start of targ seg 1089 //printf("*p = x%x, .addr = x%x, Soffset = x%x\n", *p, cast(int)SecHdrTab64[SegData[s.Sseg].SDshtidx].addr, cast(int)s.Soffset); 1090 //printf("pseg = x%x, r.offset = x%x\n", (int)SecHdrTab64[pseg.SDshtidx].addr, cast(int)r.offset); 1091 *p += SecHdrTab64[SegData[s.Sseg].SDshtidx].addr; 1092 *p += s.Soffset; 1093 *p -= SecHdrTab64[pseg.SDshtidx].addr + r.offset + 4; 1094 //patch(pseg, r.offset, s.Sseg, s.Soffset); 1095 continue; 1096 } 1097 } 1098 } 1099 else 1100 { 1101 if (s.Sclass == SCextern || 1102 s.Sclass == SCcomdef || 1103 s.Sclass == SCcomdat) 1104 { 1105 rel.r_address = cast(int)r.offset; 1106 rel.r_symbolnum = s.Sxtrnnum; 1107 rel.r_pcrel = 0; 1108 rel.r_length = 2; 1109 rel.r_extern = 1; 1110 rel.r_type = GENERIC_RELOC_VANILLA; 1111 if (I64) 1112 { 1113 rel.r_type = X86_64_RELOC_UNSIGNED; 1114 rel.r_length = 3; 1115 } 1116 fobjbuf.write(&rel, rel.sizeof); 1117 foffset += rel.sizeof; 1118 nreloc++; 1119 continue; 1120 } 1121 else 1122 { 1123 rel.r_address = cast(int)r.offset; 1124 rel.r_symbolnum = s.Sseg; 1125 rel.r_pcrel = 0; 1126 rel.r_length = 2; 1127 rel.r_extern = 0; 1128 rel.r_type = GENERIC_RELOC_VANILLA; 1129 if (I64) 1130 { 1131 rel.r_type = X86_64_RELOC_UNSIGNED; 1132 rel.r_length = 3; 1133 if (0 && s.Sseg != seg) 1134 rel.r_type = X86_64_RELOC_BRANCH; 1135 } 1136 fobjbuf.write(&rel, rel.sizeof); 1137 foffset += rel.sizeof; 1138 nreloc++; 1139 if (I64) 1140 { 1141 rel.r_length = 3; 1142 int32_t *p = patchAddr64(seg, r.offset); 1143 // Absolute address; add in addr of start of targ seg 1144 *p += SecHdrTab64[SegData[s.Sseg].SDshtidx].addr + s.Soffset; 1145 //patch(pseg, r.offset, s.Sseg, s.Soffset); 1146 } 1147 else 1148 { 1149 int32_t *p = patchAddr(seg, r.offset); 1150 // Absolute address; add in addr of start of targ seg 1151 *p += SecHdrTab[SegData[s.Sseg].SDshtidx].addr + s.Soffset; 1152 //patch(pseg, r.offset, s.Sseg, s.Soffset); 1153 } 1154 continue; 1155 } 1156 } 1157 } 1158 else if (r.rtype == RELaddr && pseg.isCode()) 1159 { 1160 srel.r_scattered = 1; 1161 1162 srel.r_address = cast(uint)r.offset; 1163 srel.r_length = 2; 1164 if (I64) 1165 { 1166 int32_t *p64 = patchAddr64(seg, r.offset); 1167 srel.r_type = X86_64_RELOC_GOT; 1168 srel.r_value = cast(int)(SecHdrTab64[SegData[r.targseg].SDshtidx].addr + *p64); 1169 //printf("SECTDIFF: x%llx + x%llx = x%x\n", SecHdrTab[SegData[r.targseg].SDshtidx].addr, *p, srel.r_value); 1170 } 1171 else 1172 { 1173 int32_t *p = patchAddr(seg, r.offset); 1174 srel.r_type = GENERIC_RELOC_LOCAL_SECTDIFF; 1175 srel.r_value = SecHdrTab[SegData[r.targseg].SDshtidx].addr + *p; 1176 //printf("SECTDIFF: x%x + x%x = x%x\n", SecHdrTab[SegData[r.targseg].SDshtidx].addr, *p, srel.r_value); 1177 } 1178 srel.r_pcrel = 0; 1179 fobjbuf.write(&srel, srel.sizeof); 1180 foffset += srel.sizeof; 1181 nreloc++; 1182 1183 srel.r_address = 0; 1184 srel.r_length = 2; 1185 if (I64) 1186 { 1187 srel.r_type = X86_64_RELOC_SIGNED; 1188 srel.r_value = cast(int)(SecHdrTab64[pseg.SDshtidx].addr + 1189 r.funcsym.Slocalgotoffset + _tysize[TYnptr]); 1190 } 1191 else 1192 { 1193 srel.r_type = GENERIC_RELOC_PAIR; 1194 if (r.funcsym) 1195 srel.r_value = cast(int)(SecHdrTab[pseg.SDshtidx].addr + 1196 r.funcsym.Slocalgotoffset + _tysize[TYnptr]); 1197 else 1198 srel.r_value = cast(int)(psechdr.addr + r.offset); 1199 //printf("srel.r_value = x%x, psechdr.addr = x%x, r.offset = x%x\n", 1200 //cast(int)srel.r_value, cast(int)psechdr.addr, cast(int)r.offset); 1201 } 1202 srel.r_pcrel = 0; 1203 fobjbuf.write(&srel, srel.sizeof); 1204 foffset += srel.sizeof; 1205 nreloc++; 1206 1207 // Recalc due to possible realloc of fobjbuf.buf 1208 if (I64) 1209 { 1210 int32_t *p64 = patchAddr64(seg, r.offset); 1211 //printf("address = x%x, p64 = %p *p64 = x%llx\n", r.offset, p64, *p64); 1212 *p64 += SecHdrTab64[SegData[r.targseg].SDshtidx].addr - 1213 (SecHdrTab64[pseg.SDshtidx].addr + r.funcsym.Slocalgotoffset + _tysize[TYnptr]); 1214 } 1215 else 1216 { 1217 int32_t *p = patchAddr(seg, r.offset); 1218 //printf("address = x%x, p = %p *p = x%x\n", r.offset, p, *p); 1219 if (r.funcsym) 1220 *p += SecHdrTab[SegData[r.targseg].SDshtidx].addr - 1221 (SecHdrTab[pseg.SDshtidx].addr + r.funcsym.Slocalgotoffset + _tysize[TYnptr]); 1222 else 1223 // targ_address - fixup_address 1224 *p += SecHdrTab[SegData[r.targseg].SDshtidx].addr - 1225 (psechdr.addr + r.offset); 1226 } 1227 continue; 1228 } 1229 else 1230 { 1231 rel.r_address = cast(int)r.offset; 1232 rel.r_symbolnum = r.targseg; 1233 rel.r_pcrel = (r.rtype == RELaddr) ? 0 : 1; 1234 rel.r_length = 2; 1235 rel.r_extern = 0; 1236 rel.r_type = GENERIC_RELOC_VANILLA; 1237 if (I64) 1238 { 1239 rel.r_type = X86_64_RELOC_UNSIGNED; 1240 rel.r_length = 3; 1241 if (0 && r.targseg != seg) 1242 rel.r_type = X86_64_RELOC_BRANCH; 1243 } 1244 fobjbuf.write(&rel, rel.sizeof); 1245 foffset += rel.sizeof; 1246 nreloc++; 1247 if (I64) 1248 { 1249 int32_t *p64 = patchAddr64(seg, r.offset); 1250 //int64_t before = *p64; 1251 if (rel.r_pcrel) 1252 // Relative address 1253 patch(pseg, r.offset, r.targseg, 0); 1254 else 1255 { // Absolute address; add in addr of start of targ seg 1256 //printf("*p = x%x, targ.addr = x%x\n", *p64, cast(int)SecHdrTab64[SegData[r.targseg].SDshtidx].addr); 1257 //printf("pseg = x%x, r.offset = x%x\n", cast(int)SecHdrTab64[pseg.SDshtidx].addr, cast(int)r.offset); 1258 *p64 += SecHdrTab64[SegData[r.targseg].SDshtidx].addr; 1259 //*p64 -= SecHdrTab64[pseg.SDshtidx].addr; 1260 } 1261 //printf("%d:x%04x before = x%04llx, after = x%04llx pcrel = %d\n", seg, r.offset, before, *p64, rel.r_pcrel); 1262 } 1263 else 1264 { 1265 int32_t *p = patchAddr(seg, r.offset); 1266 //int32_t before = *p; 1267 if (rel.r_pcrel) 1268 // Relative address 1269 patch(pseg, r.offset, r.targseg, 0); 1270 else 1271 // Absolute address; add in addr of start of targ seg 1272 *p += SecHdrTab[SegData[r.targseg].SDshtidx].addr; 1273 //printf("%d:x%04x before = x%04x, after = x%04x pcrel = %d\n", seg, r.offset, before, *p, rel.r_pcrel); 1274 } 1275 continue; 1276 } 1277 } 1278 } 1279 if (nreloc) 1280 { 1281 if (I64) 1282 { 1283 psechdr64.reloff = reloff; 1284 psechdr64.nreloc = nreloc; 1285 } 1286 else 1287 { 1288 psechdr.reloff = reloff; 1289 psechdr.nreloc = nreloc; 1290 } 1291 } 1292 } 1293 1294 // Put out symbol table 1295 foffset = elf_align(I64 ? 8 : 4, foffset); 1296 symtab_cmd.symoff = foffset; 1297 dysymtab_cmd.ilocalsym = 0; 1298 dysymtab_cmd.nlocalsym = cast(uint)(local_symbuf.length() / (Symbol *).sizeof); 1299 dysymtab_cmd.iextdefsym = dysymtab_cmd.nlocalsym; 1300 dysymtab_cmd.nextdefsym = cast(uint)(public_symbuf.length() / (Symbol *).sizeof); 1301 dysymtab_cmd.iundefsym = dysymtab_cmd.iextdefsym + dysymtab_cmd.nextdefsym; 1302 int nexterns = cast(int)(extern_symbuf.length() / (Symbol *).sizeof); 1303 int ncomdefs = cast(int)(comdef_symbuf.length() / Comdef.sizeof); 1304 dysymtab_cmd.nundefsym = nexterns + ncomdefs; 1305 symtab_cmd.nsyms = dysymtab_cmd.nlocalsym + 1306 dysymtab_cmd.nextdefsym + 1307 dysymtab_cmd.nundefsym; 1308 fobjbuf.reserve(cast(uint)(symtab_cmd.nsyms * (I64 ? nlist_64.sizeof : nlist.sizeof))); 1309 for (int i = 0; i < dysymtab_cmd.nlocalsym; i++) 1310 { Symbol *s = (cast(Symbol **)local_symbuf.buf)[i]; 1311 nlist_64 sym = void; 1312 sym.n_strx = elf_addmangled(s); 1313 sym.n_type = N_SECT; 1314 sym.n_desc = 0; 1315 if (s.Sclass == SCcomdat) 1316 sym.n_desc = N_WEAK_DEF; 1317 sym.n_sect = cast(ubyte)s.Sseg; 1318 if (I64) 1319 { 1320 sym.n_value = s.Soffset + SecHdrTab64[SegData[s.Sseg].SDshtidx].addr; 1321 fobjbuf.write(&sym, sym.sizeof); 1322 } 1323 else 1324 { 1325 nlist sym32 = void; 1326 sym32.n_strx = sym.n_strx; 1327 sym32.n_value = cast(uint)(s.Soffset + SecHdrTab[SegData[s.Sseg].SDshtidx].addr); 1328 sym32.n_type = sym.n_type; 1329 sym32.n_desc = sym.n_desc; 1330 sym32.n_sect = sym.n_sect; 1331 fobjbuf.write(&sym32, sym32.sizeof); 1332 } 1333 } 1334 for (int i = 0; i < dysymtab_cmd.nextdefsym; i++) 1335 { Symbol *s = (cast(Symbol **)public_symbuf.buf)[i]; 1336 1337 //printf("Writing public symbol %d:x%x %s\n", s.Sseg, s.Soffset, s.Sident); 1338 nlist_64 sym = void; 1339 sym.n_strx = elf_addmangled(s); 1340 sym.n_type = N_EXT | N_SECT; 1341 if (s.Sflags & SFLhidden) 1342 sym.n_type |= N_PEXT; // private extern 1343 sym.n_desc = 0; 1344 if (s.Sclass == SCcomdat) 1345 sym.n_desc = N_WEAK_DEF; 1346 sym.n_sect = cast(ubyte)s.Sseg; 1347 if (I64) 1348 { 1349 sym.n_value = s.Soffset + SecHdrTab64[SegData[s.Sseg].SDshtidx].addr; 1350 fobjbuf.write(&sym, sym.sizeof); 1351 } 1352 else 1353 { 1354 nlist sym32 = void; 1355 sym32.n_strx = sym.n_strx; 1356 sym32.n_value = cast(uint)(s.Soffset + SecHdrTab[SegData[s.Sseg].SDshtidx].addr); 1357 sym32.n_type = sym.n_type; 1358 sym32.n_desc = sym.n_desc; 1359 sym32.n_sect = sym.n_sect; 1360 fobjbuf.write(&sym32, sym32.sizeof); 1361 } 1362 } 1363 for (int i = 0; i < nexterns; i++) 1364 { Symbol *s = (cast(Symbol **)extern_symbuf.buf)[i]; 1365 nlist_64 sym = void; 1366 sym.n_strx = elf_addmangled(s); 1367 sym.n_value = s.Soffset; 1368 sym.n_type = N_EXT | N_UNDF; 1369 sym.n_desc = tyfunc(s.ty()) ? REFERENCE_FLAG_UNDEFINED_LAZY 1370 : REFERENCE_FLAG_UNDEFINED_NON_LAZY; 1371 sym.n_sect = 0; 1372 if (I64) 1373 fobjbuf.write(&sym, sym.sizeof); 1374 else 1375 { 1376 nlist sym32 = void; 1377 sym32.n_strx = sym.n_strx; 1378 sym32.n_value = cast(uint)sym.n_value; 1379 sym32.n_type = sym.n_type; 1380 sym32.n_desc = sym.n_desc; 1381 sym32.n_sect = sym.n_sect; 1382 fobjbuf.write(&sym32, sym32.sizeof); 1383 } 1384 } 1385 for (int i = 0; i < ncomdefs; i++) 1386 { Comdef *c = (cast(Comdef *)comdef_symbuf.buf) + i; 1387 nlist_64 sym = void; 1388 sym.n_strx = elf_addmangled(c.sym); 1389 sym.n_value = c.size * c.count; 1390 sym.n_type = N_EXT | N_UNDF; 1391 int align_; 1392 if (c.size < 2) 1393 align_ = 0; // align_ is expressed as power of 2 1394 else if (c.size < 4) 1395 align_ = 1; 1396 else if (c.size < 8) 1397 align_ = 2; 1398 else if (c.size < 16) 1399 align_ = 3; 1400 else 1401 align_ = 4; 1402 sym.n_desc = cast(ushort)(align_ << 8); 1403 sym.n_sect = 0; 1404 if (I64) 1405 fobjbuf.write(&sym, sym.sizeof); 1406 else 1407 { 1408 nlist sym32 = void; 1409 sym32.n_strx = sym.n_strx; 1410 sym32.n_value = cast(uint)sym.n_value; 1411 sym32.n_type = sym.n_type; 1412 sym32.n_desc = sym.n_desc; 1413 sym32.n_sect = sym.n_sect; 1414 fobjbuf.write(&sym32, sym32.sizeof); 1415 } 1416 } 1417 if (extdef) 1418 { 1419 nlist_64 sym = void; 1420 sym.n_strx = extdef; 1421 sym.n_value = 0; 1422 sym.n_type = N_EXT | N_UNDF; 1423 sym.n_desc = 0; 1424 sym.n_sect = 0; 1425 if (I64) 1426 fobjbuf.write(&sym, sym.sizeof); 1427 else 1428 { 1429 nlist sym32 = void; 1430 sym32.n_strx = sym.n_strx; 1431 sym32.n_value = cast(uint)sym.n_value; 1432 sym32.n_type = sym.n_type; 1433 sym32.n_desc = sym.n_desc; 1434 sym32.n_sect = sym.n_sect; 1435 fobjbuf.write(&sym32, sym32.sizeof); 1436 } 1437 symtab_cmd.nsyms++; 1438 } 1439 foffset += symtab_cmd.nsyms * (I64 ? nlist_64.sizeof : nlist.sizeof); 1440 1441 // Put out string table 1442 foffset = elf_align(I64 ? 8 : 4, foffset); 1443 symtab_cmd.stroff = foffset; 1444 symtab_cmd.strsize = cast(uint)symtab_strings.length(); 1445 fobjbuf.write(symtab_strings.buf, symtab_cmd.strsize); 1446 foffset += symtab_cmd.strsize; 1447 1448 // Put out indirectsym table, which is in two parts 1449 foffset = elf_align(I64 ? 8 : 4, foffset); 1450 dysymtab_cmd.indirectsymoff = foffset; 1451 if (indirectsymbuf1) 1452 { 1453 dysymtab_cmd.nindirectsyms += indirectsymbuf1.length() / (Symbol *).sizeof; 1454 for (int i = 0; i < dysymtab_cmd.nindirectsyms; i++) 1455 { Symbol *s = (cast(Symbol **)indirectsymbuf1.buf)[i]; 1456 fobjbuf.write32(s.Sxtrnnum); 1457 } 1458 } 1459 if (indirectsymbuf2) 1460 { 1461 int n = cast(int)(indirectsymbuf2.length() / (Symbol *).sizeof); 1462 dysymtab_cmd.nindirectsyms += n; 1463 for (int i = 0; i < n; i++) 1464 { Symbol *s = (cast(Symbol **)indirectsymbuf2.buf)[i]; 1465 fobjbuf.write32(s.Sxtrnnum); 1466 } 1467 } 1468 foffset += dysymtab_cmd.nindirectsyms * 4; 1469 1470 /* The correct offsets are now determined, so 1471 * rewind and fix the header. 1472 */ 1473 fobjbuf.position(headersize, sizeofcmds); 1474 if (I64) 1475 { 1476 fobjbuf.write(&segment_cmd64, segment_cmd64.sizeof); 1477 fobjbuf.write(SECbuf.buf + section_64.sizeof, cast(uint)((section_cnt - 1) * section_64.sizeof)); 1478 } 1479 else 1480 { 1481 fobjbuf.write(&segment_cmd, segment_cmd.sizeof); 1482 fobjbuf.write(SECbuf.buf + section.sizeof, cast(uint)((section_cnt - 1) * section.sizeof)); 1483 } 1484 fobjbuf.write(&symtab_cmd, symtab_cmd.sizeof); 1485 fobjbuf.write(&dysymtab_cmd, dysymtab_cmd.sizeof); 1486 fobjbuf.position(foffset, 0); 1487 } 1488 1489 /***************************** 1490 * Line number support. 1491 */ 1492 1493 /*************************** 1494 * Record file and line number at segment and offset. 1495 * The actual .debug_line segment is put out by dwarf_termfile(). 1496 * Params: 1497 * srcpos = source file position 1498 * seg = segment it corresponds to 1499 * offset = offset within seg 1500 */ 1501 1502 void Obj_linnum(Srcpos srcpos, int seg, targ_size_t offset) 1503 { 1504 if (srcpos.Slinnum == 0) 1505 return; 1506 1507 static if (0) 1508 { 1509 printf("Obj_linnum(seg=%d, offset=x%lx) ", seg, offset); 1510 srcpos.print(""); 1511 } 1512 1513 version (MARS) 1514 { 1515 if (!srcpos.Sfilename) 1516 return; 1517 } 1518 version (SCPP) 1519 { 1520 if (!srcpos.Sfilptr) 1521 return; 1522 sfile_debug(&srcpos_sfile(srcpos)); 1523 Sfile *sf = *srcpos.Sfilptr; 1524 } 1525 1526 size_t i; 1527 seg_data *pseg = SegData[seg]; 1528 1529 // Find entry i in SDlinnum_data[] that corresponds to srcpos filename 1530 for (i = 0; 1; i++) 1531 { 1532 if (i == pseg.SDlinnum_count) 1533 { // Create new entry 1534 if (pseg.SDlinnum_count == pseg.SDlinnum_max) 1535 { // Enlarge array 1536 uint newmax = pseg.SDlinnum_max * 2 + 1; 1537 //printf("realloc %d\n", newmax * linnum_data.sizeof); 1538 pseg.SDlinnum_data = cast(linnum_data *)mem_realloc( 1539 pseg.SDlinnum_data, newmax * linnum_data.sizeof); 1540 memset(pseg.SDlinnum_data + pseg.SDlinnum_max, 0, 1541 (newmax - pseg.SDlinnum_max) * linnum_data.sizeof); 1542 pseg.SDlinnum_max = newmax; 1543 } 1544 pseg.SDlinnum_count++; 1545 version (MARS) 1546 { 1547 pseg.SDlinnum_data[i].filename = srcpos.Sfilename; 1548 } 1549 version (SCPP) 1550 { 1551 pseg.SDlinnum_data[i].filptr = sf; 1552 } 1553 break; 1554 } 1555 version (MARS) 1556 { 1557 if (pseg.SDlinnum_data[i].filename == srcpos.Sfilename) 1558 break; 1559 } 1560 version (SCPP) 1561 { 1562 if (pseg.SDlinnum_data[i].filptr == sf) 1563 break; 1564 } 1565 } 1566 1567 linnum_data *ld = &pseg.SDlinnum_data[i]; 1568 // printf("i = %d, ld = x%x\n", i, ld); 1569 if (ld.linoff_count == ld.linoff_max) 1570 { 1571 if (!ld.linoff_max) 1572 ld.linoff_max = 8; 1573 ld.linoff_max *= 2; 1574 ld.linoff = cast(uint[2]*)mem_realloc(ld.linoff, ld.linoff_max * uint.sizeof * 2); 1575 } 1576 ld.linoff[ld.linoff_count][0] = srcpos.Slinnum; 1577 ld.linoff[ld.linoff_count][1] = cast(uint)offset; 1578 ld.linoff_count++; 1579 } 1580 1581 1582 /******************************* 1583 * Set start address 1584 */ 1585 1586 void Obj_startaddress(Symbol *s) 1587 { 1588 //dbg_printf("Obj_startaddress(Symbol *%s)\n",s.Sident); 1589 //obj.startaddress = s; 1590 } 1591 1592 /******************************* 1593 * Output library name. 1594 */ 1595 1596 bool Obj_includelib(const(char)* name) 1597 { 1598 //dbg_printf("Obj_includelib(name *%s)\n",name); 1599 return false; 1600 } 1601 1602 /******************************* 1603 * Output linker directive. 1604 */ 1605 1606 bool Obj_linkerdirective(const(char)* name) 1607 { 1608 return false; 1609 } 1610 1611 /********************************** 1612 * Do we allow zero sized objects? 1613 */ 1614 1615 bool Obj_allowZeroSize() 1616 { 1617 return true; 1618 } 1619 1620 /************************** 1621 * Embed string in executable. 1622 */ 1623 1624 void Obj_exestr(const(char)* p) 1625 { 1626 //dbg_printf("Obj_exestr(char *%s)\n",p); 1627 } 1628 1629 /************************** 1630 * Embed string in obj. 1631 */ 1632 1633 void Obj_user(const(char)* p) 1634 { 1635 //dbg_printf("Obj_user(char *%s)\n",p); 1636 } 1637 1638 /******************************* 1639 * Output a weak extern record. 1640 */ 1641 1642 void Obj_wkext(Symbol *s1,Symbol *s2) 1643 { 1644 //dbg_printf("Obj_wkext(Symbol *%s,Symbol *s2)\n",s1.Sident.ptr,s2.Sident.ptr); 1645 } 1646 1647 /******************************* 1648 * Output file name record. 1649 * 1650 * Currently assumes that obj_filename will not be called 1651 * twice for the same file. 1652 */ 1653 1654 void obj_filename(const(char)* modname) 1655 { 1656 //dbg_printf("obj_filename(char *%s)\n",modname); 1657 // Not supported by Mach-O 1658 } 1659 1660 /******************************* 1661 * Embed compiler version in .obj file. 1662 */ 1663 1664 void Obj_compiler() 1665 { 1666 //dbg_printf("Obj_compiler\n"); 1667 } 1668 1669 1670 /************************************** 1671 * Symbol is the function that calls the static constructors. 1672 * Put a pointer to it into a special segment that the startup code 1673 * looks at. 1674 * Input: 1675 * s static constructor function 1676 * dtor !=0 if leave space for static destructor 1677 * seg 1: user 1678 * 2: lib 1679 * 3: compiler 1680 */ 1681 1682 void Obj_staticctor(Symbol *s, int, int) 1683 { 1684 Obj_setModuleCtorDtor(s, true); 1685 } 1686 1687 /************************************** 1688 * Symbol is the function that calls the static destructors. 1689 * Put a pointer to it into a special segment that the exit code 1690 * looks at. 1691 * Input: 1692 * s static destructor function 1693 */ 1694 1695 void Obj_staticdtor(Symbol *s) 1696 { 1697 Obj_setModuleCtorDtor(s, false); 1698 } 1699 1700 1701 /*************************************** 1702 * Stuff pointer to function in its own segment. 1703 * Used for static ctor and dtor lists. 1704 */ 1705 1706 void Obj_setModuleCtorDtor(Symbol *sfunc, bool isCtor) 1707 { 1708 const(char)* secname = isCtor ? "__mod_init_func" : "__mod_term_func"; 1709 const int align_ = I64 ? 3 : 2; // align to _tysize[TYnptr] 1710 const int flags = isCtor ? S_MOD_INIT_FUNC_POINTERS : S_MOD_TERM_FUNC_POINTERS; 1711 IDXSEC seg = Obj_getsegment(secname, "__DATA", align_, flags); 1712 1713 const int relflags = I64 ? CFoff | CFoffset64 : CFoff; 1714 const int sz = Obj_reftoident(seg, SegData[seg].SDoffset, sfunc, 0, relflags); 1715 SegData[seg].SDoffset += sz; 1716 } 1717 1718 1719 /*************************************** 1720 * Stuff the following data (instance of struct FuncTable) in a separate segment: 1721 * pointer to function 1722 * pointer to ehsym 1723 * length of function 1724 */ 1725 1726 void Obj_ehtables(Symbol *sfunc,uint size,Symbol *ehsym) 1727 { 1728 //dbg_printf("Obj_ehtables(%s) \n",sfunc.Sident.ptr); 1729 1730 /* BUG: this should go into a COMDAT if sfunc is in a COMDAT 1731 * otherwise the duplicates aren't removed. 1732 */ 1733 1734 int align_ = I64 ? 3 : 2; // align to _tysize[TYnptr] 1735 // The size is (FuncTable).sizeof in deh2.d 1736 int seg = Obj_getsegment("__deh_eh", "__DATA", align_, S_REGULAR); 1737 1738 Outbuffer *buf = SegData[seg].SDbuf; 1739 if (I64) 1740 { 1741 Obj_reftoident(seg, buf.length(), sfunc, 0, CFoff | CFoffset64); 1742 Obj_reftoident(seg, buf.length(), ehsym, 0, CFoff | CFoffset64); 1743 buf.write64(sfunc.Ssize); 1744 } 1745 else 1746 { 1747 Obj_reftoident(seg, buf.length(), sfunc, 0, CFoff); 1748 Obj_reftoident(seg, buf.length(), ehsym, 0, CFoff); 1749 buf.write32(cast(int)sfunc.Ssize); 1750 } 1751 } 1752 1753 /********************************************* 1754 * Put out symbols that define the beginning/end of the .deh_eh section. 1755 * This gets called if this is the module with "main()" in it. 1756 */ 1757 1758 void Obj_ehsections() 1759 { 1760 //printf("Obj_ehsections()\n"); 1761 } 1762 1763 /********************************* 1764 * Setup for Symbol s to go into a COMDAT segment. 1765 * Output (if s is a function): 1766 * cseg segment index of new current code segment 1767 * Offset(cseg) starting offset in cseg 1768 * Returns: 1769 * "segment index" of COMDAT 1770 */ 1771 1772 int Obj_comdatsize(Symbol *s, targ_size_t symsize) 1773 { 1774 return Obj_comdat(s); 1775 } 1776 1777 int Obj_comdat(Symbol *s) 1778 { 1779 const(char)* sectname; 1780 const(char)* segname; 1781 int align_; 1782 int flags; 1783 1784 //printf("Obj_comdat(Symbol* %s)\n",s.Sident.ptr); 1785 //symbol_print(s); 1786 symbol_debug(s); 1787 1788 if (tyfunc(s.ty())) 1789 { 1790 sectname = "__textcoal_nt"; 1791 segname = "__TEXT"; 1792 align_ = 2; // 4 byte alignment 1793 flags = S_COALESCED | S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS; 1794 s.Sseg = Obj_getsegment(sectname, segname, align_, flags); 1795 } 1796 else if ((s.ty() & mTYLINK) == mTYthread) 1797 { 1798 s.Sfl = FLtlsdata; 1799 align_ = 4; 1800 if (I64) 1801 s.Sseg = objmod.tlsseg().SDseg; 1802 else 1803 s.Sseg = Obj_getsegment("__tlscoal_nt", "__DATA", align_, S_COALESCED); 1804 Obj_data_start(s, 1 << align_, s.Sseg); 1805 } 1806 else 1807 { 1808 s.Sfl = FLdata; 1809 sectname = "__datacoal_nt"; 1810 segname = "__DATA"; 1811 align_ = 4; // 16 byte alignment 1812 s.Sseg = Obj_getsegment(sectname, segname, align_, S_COALESCED); 1813 Obj_data_start(s, 1 << align_, s.Sseg); 1814 } 1815 // find or create new segment 1816 if (s.Salignment > (1 << align_)) 1817 SegData[s.Sseg].SDalignment = s.Salignment; 1818 s.Soffset = SegData[s.Sseg].SDoffset; 1819 if (s.Sfl == FLdata || s.Sfl == FLtlsdata) 1820 { // Code symbols are 'published' by Obj_func_start() 1821 1822 Obj_pubdef(s.Sseg,s,s.Soffset); 1823 searchfixlist(s); // backpatch any refs to this symbol 1824 } 1825 return s.Sseg; 1826 } 1827 1828 int Obj_readonly_comdat(Symbol *s) 1829 { 1830 assert(0); 1831 } 1832 1833 /*********************************** 1834 * Returns: 1835 * jump table segment for function s 1836 */ 1837 int Obj_jmpTableSegment(Symbol *s) 1838 { 1839 return (config.flags & CFGromable) ? cseg : CDATA; 1840 } 1841 1842 /********************************** 1843 * Get segment. 1844 * Input: 1845 * align_ segment alignment as power of 2 1846 * Returns: 1847 * segment index of found or newly created segment 1848 */ 1849 1850 int Obj_getsegment(const(char)* sectname, const(char)* segname, 1851 int align_, int flags) 1852 { 1853 assert(strlen(sectname) <= 16); 1854 assert(strlen(segname) <= 16); 1855 for (int seg = 1; seg <= seg_count; seg++) 1856 { seg_data *pseg = SegData[seg]; 1857 if (I64) 1858 { 1859 if (strncmp(SecHdrTab64[pseg.SDshtidx].sectname.ptr, sectname, 16) == 0 && 1860 strncmp(SecHdrTab64[pseg.SDshtidx].segname.ptr, segname, 16) == 0) 1861 return seg; // return existing segment 1862 } 1863 else 1864 { 1865 if (strncmp(SecHdrTab[pseg.SDshtidx].sectname.ptr, sectname, 16) == 0 && 1866 strncmp(SecHdrTab[pseg.SDshtidx].segname.ptr, segname, 16) == 0) 1867 return seg; // return existing segment 1868 } 1869 } 1870 1871 int seg = ++seg_count; 1872 if (seg_count >= seg_max) 1873 { // need more room in segment table 1874 seg_max += 10; 1875 SegData = cast(seg_data **)mem_realloc(SegData,seg_max * (seg_data *).sizeof); 1876 memset(&SegData[seg_count], 0, (seg_max - seg_count) * (seg_data *).sizeof); 1877 } 1878 assert(seg_count < seg_max); 1879 if (SegData[seg]) 1880 { seg_data *pseg = SegData[seg]; 1881 Outbuffer *b1 = pseg.SDbuf; 1882 Outbuffer *b2 = pseg.SDrel; 1883 memset(pseg, 0, seg_data.sizeof); 1884 if (b1) 1885 b1.reset(); 1886 if (b2) 1887 b2.reset(); 1888 pseg.SDbuf = b1; 1889 pseg.SDrel = b2; 1890 } 1891 else 1892 { 1893 seg_data *pseg = cast(seg_data *)mem_calloc(seg_data.sizeof); 1894 SegData[seg] = pseg; 1895 if (flags != S_ZEROFILL) 1896 { 1897 pseg.SDbuf = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 1898 assert(pseg.SDbuf); 1899 pseg.SDbuf.reserve(4096); 1900 } 1901 } 1902 1903 //dbg_printf("\tNew segment - %d size %d\n", seg,SegData[seg].SDbuf); 1904 seg_data *pseg = SegData[seg]; 1905 1906 pseg.SDseg = seg; 1907 pseg.SDoffset = 0; 1908 1909 if (I64) 1910 { 1911 section_64 *sec = cast(section_64 *) 1912 SECbuf.writezeros(section_64.sizeof); 1913 strncpy(sec.sectname.ptr, sectname, 16); 1914 strncpy(sec.segname.ptr, segname, 16); 1915 sec._align = align_; 1916 sec.flags = flags; 1917 } 1918 else 1919 { 1920 section *sec = cast(section *) 1921 SECbuf.writezeros(section.sizeof); 1922 strncpy(sec.sectname.ptr, sectname, 16); 1923 strncpy(sec.segname.ptr, segname, 16); 1924 sec._align = align_; 1925 sec.flags = flags; 1926 } 1927 1928 pseg.SDshtidx = section_cnt++; 1929 pseg.SDaranges_offset = 0; 1930 pseg.SDlinnum_count = 0; 1931 1932 //printf("seg_count = %d\n", seg_count); 1933 return seg; 1934 } 1935 1936 /********************************** 1937 * Reset code seg to existing seg. 1938 * Used after a COMDAT for a function is done. 1939 */ 1940 1941 void Obj_setcodeseg(int seg) 1942 { 1943 cseg = seg; 1944 } 1945 1946 /******************************** 1947 * Define a new code segment. 1948 * Input: 1949 * name name of segment, if null then revert to default 1950 * suffix 0 use name as is 1951 * 1 append "_TEXT" to name 1952 * Output: 1953 * cseg segment index of new current code segment 1954 * Offset(cseg) starting offset in cseg 1955 * Returns: 1956 * segment index of newly created code segment 1957 */ 1958 1959 int Obj_codeseg(const char *name,int suffix) 1960 { 1961 //dbg_printf("Obj_codeseg(%s,%x)\n",name,suffix); 1962 static if (0) 1963 { 1964 const(char)* sfx = (suffix) ? "_TEXT" : null; 1965 1966 if (!name) // returning to default code segment 1967 { 1968 if (cseg != CODE) // not the current default 1969 { 1970 SegData[cseg].SDoffset = Offset(cseg); 1971 Offset(cseg) = SegData[CODE].SDoffset; 1972 cseg = CODE; 1973 } 1974 return cseg; 1975 } 1976 1977 int seg = ElfObj_getsegment(name, sfx, SHT_PROGDEF, SHF_ALLOC|SHF_EXECINSTR, 4); 1978 // find or create code segment 1979 1980 cseg = seg; // new code segment index 1981 Offset(cseg) = 0; 1982 return seg; 1983 } 1984 else 1985 { 1986 return 0; 1987 } 1988 } 1989 1990 /********************************* 1991 * Define segments for Thread Local Storage for 32bit. 1992 * Output: 1993 * seg_tlsseg set to segment number for TLS segment. 1994 * Returns: 1995 * segment for TLS segment 1996 */ 1997 1998 seg_data *Obj_tlsseg() 1999 { 2000 //printf("Obj_tlsseg(\n"); 2001 if (I32) 2002 { 2003 if (seg_tlsseg == UNKNOWN) 2004 seg_tlsseg = Obj_getsegment("__tls_data", "__DATA", 2, S_REGULAR); 2005 return SegData[seg_tlsseg]; 2006 } 2007 else 2008 { 2009 if (seg_tlsseg == UNKNOWN) 2010 seg_tlsseg = Obj_getsegment("__thread_vars", "__DATA", 0, S_THREAD_LOCAL_VARIABLES); 2011 return SegData[seg_tlsseg]; 2012 } 2013 } 2014 2015 2016 /********************************* 2017 * Define segments for Thread Local Storage. 2018 * Output: 2019 * seg_tlsseg_bss set to segment number for TLS segment. 2020 * Returns: 2021 * segment for TLS segment 2022 */ 2023 2024 seg_data *Obj_tlsseg_bss() 2025 { 2026 2027 if (I32) 2028 { 2029 /* Because DMD does not support native tls for Mach-O 32bit, 2030 * it's easier to support if we have all the tls in one segment. 2031 */ 2032 return Obj_tlsseg(); 2033 } 2034 else 2035 { 2036 // The alignment should actually be alignment of the largest variable in 2037 // the section, but this seems to work anyway. 2038 if (seg_tlsseg_bss == UNKNOWN) 2039 seg_tlsseg_bss = Obj_getsegment("__thread_bss", "__DATA", 3, S_THREAD_LOCAL_ZEROFILL); 2040 return SegData[seg_tlsseg_bss]; 2041 } 2042 } 2043 2044 /********************************* 2045 * Define segments for Thread Local Storage data. 2046 * Output: 2047 * seg_tlsseg_data set to segment number for TLS data segment. 2048 * Returns: 2049 * segment for TLS data segment 2050 */ 2051 2052 seg_data *Obj_tlsseg_data() 2053 { 2054 //printf("Obj_tlsseg_data(\n"); 2055 assert(I64); 2056 2057 // The alignment should actually be alignment of the largest variable in 2058 // the section, but this seems to work anyway. 2059 if (seg_tlsseg_data == UNKNOWN) 2060 seg_tlsseg_data = Obj_getsegment("__thread_data", "__DATA", 4, S_THREAD_LOCAL_REGULAR); 2061 return SegData[seg_tlsseg_data]; 2062 } 2063 2064 /******************************* 2065 * Output an alias definition record. 2066 */ 2067 2068 void Obj_alias(const(char)* n1,const(char)* n2) 2069 { 2070 //printf("Obj_alias(%s,%s)\n",n1,n2); 2071 assert(0); 2072 static if (0) 2073 { 2074 uint len; 2075 char *buffer; 2076 2077 buffer = cast(char *) alloca(strlen(n1) + strlen(n2) + 2 * ONS_OHD); 2078 len = obj_namestring(buffer,n1); 2079 len += obj_namestring(buffer + len,n2); 2080 objrecord(ALIAS,buffer,len); 2081 } 2082 } 2083 2084 char *unsstr (uint value) 2085 { 2086 __gshared char[64] buffer = void; 2087 2088 sprintf (buffer.ptr, "%d", value); 2089 return buffer.ptr; 2090 } 2091 2092 /******************************* 2093 * Mangle a name. 2094 * Returns: 2095 * mangled name 2096 */ 2097 2098 char *obj_mangle2(Symbol *s,char *dest) 2099 { 2100 size_t len; 2101 char *name; 2102 2103 //printf("Obj_mangle(s = %p, '%s'), mangle = x%x\n",s,s.Sident.ptr,type_mangle(s.Stype)); 2104 symbol_debug(s); 2105 assert(dest); 2106 version (SCPP) 2107 { 2108 name = CPP ? cpp_mangle(s) : s.Sident.ptr; 2109 } 2110 else version (MARS) 2111 { 2112 // C++ name mangling is handled by front end 2113 name = s.Sident.ptr; 2114 } 2115 else 2116 { 2117 name = s.Sident.ptr; 2118 } 2119 len = strlen(name); // # of bytes in name 2120 //dbg_printf("len %d\n",len); 2121 switch (type_mangle(s.Stype)) 2122 { 2123 case mTYman_pas: // if upper case 2124 case mTYman_for: 2125 if (len >= DEST_LEN) 2126 dest = cast(char *)mem_malloc(len + 1); 2127 memcpy(dest,name,len + 1); // copy in name and ending 0 2128 for (char *p = dest; *p; p++) 2129 *p = cast(char)toupper(*p); 2130 break; 2131 case mTYman_std: 2132 { 2133 static if (TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_DRAGONFLYBSD || TARGET_SOLARIS) 2134 bool cond = (tyfunc(s.ty()) && !variadic(s.Stype)); 2135 else 2136 bool cond = (!(config.flags4 & CFG4oldstdmangle) && 2137 config.exe == EX_WIN32 && tyfunc(s.ty()) && 2138 !variadic(s.Stype)); 2139 2140 if (cond) 2141 { 2142 char *pstr = unsstr(type_paramsize(s.Stype)); 2143 size_t pstrlen = strlen(pstr); 2144 size_t destlen = len + 1 + pstrlen + 1; 2145 2146 if (destlen > DEST_LEN) 2147 dest = cast(char *)mem_malloc(destlen); 2148 memcpy(dest,name,len); 2149 dest[len] = '@'; 2150 memcpy(dest + 1 + len, pstr, pstrlen + 1); 2151 break; 2152 } 2153 goto case; 2154 } 2155 case mTYman_sys: 2156 case 0: 2157 if (len >= DEST_LEN) 2158 dest = cast(char *)mem_malloc(len + 1); 2159 memcpy(dest,name,len+1);// copy in name and trailing 0 2160 break; 2161 2162 case mTYman_c: 2163 case mTYman_cpp: 2164 case mTYman_d: 2165 if (len >= DEST_LEN - 1) 2166 dest = cast(char *)mem_malloc(1 + len + 1); 2167 dest[0] = '_'; 2168 memcpy(dest + 1,name,len+1);// copy in name and trailing 0 2169 break; 2170 2171 2172 default: 2173 debug 2174 { 2175 printf("mangling %x\n",type_mangle(s.Stype)); 2176 symbol_print(s); 2177 } 2178 printf("%d\n", type_mangle(s.Stype)); 2179 assert(0); 2180 } 2181 //dbg_printf("\t %s\n",dest); 2182 return dest; 2183 } 2184 2185 /******************************* 2186 * Export a function name. 2187 */ 2188 2189 void Obj_export_symbol(Symbol *s,uint argsize) 2190 { 2191 //dbg_printf("Obj_export_symbol(%s,%d)\n",s.Sident.ptr,argsize); 2192 } 2193 2194 /******************************* 2195 * Update data information about symbol 2196 * align for output and assign segment 2197 * if not already specified. 2198 * 2199 * Input: 2200 * sdata data symbol 2201 * datasize output size 2202 * seg default seg if not known 2203 * Returns: 2204 * actual seg 2205 */ 2206 2207 int Obj_data_start(Symbol *sdata, targ_size_t datasize, int seg) 2208 { 2209 targ_size_t alignbytes; 2210 2211 //printf("Obj_data_start(%s,size %llu,seg %d)\n",sdata.Sident.ptr,datasize,seg); 2212 //symbol_print(sdata); 2213 2214 assert(sdata.Sseg); 2215 if (sdata.Sseg == UNKNOWN) // if we don't know then there 2216 sdata.Sseg = seg; // wasn't any segment override 2217 else 2218 seg = sdata.Sseg; 2219 targ_size_t offset = Offset(seg); 2220 if (sdata.Salignment > 0) 2221 { if (SegData[seg].SDalignment < sdata.Salignment) 2222 SegData[seg].SDalignment = sdata.Salignment; 2223 alignbytes = ((offset + sdata.Salignment - 1) & ~(sdata.Salignment - 1)) - offset; 2224 } 2225 else 2226 alignbytes = _align(datasize, offset) - offset; 2227 if (alignbytes) 2228 Obj_lidata(seg, offset, alignbytes); 2229 sdata.Soffset = offset + alignbytes; 2230 return seg; 2231 } 2232 2233 /******************************* 2234 * Update function info before codgen 2235 * 2236 * If code for this function is in a different segment 2237 * than the current default in cseg, switch cseg to new segment. 2238 */ 2239 2240 void Obj_func_start(Symbol *sfunc) 2241 { 2242 //printf("Obj_func_start(%s)\n",sfunc.Sident.ptr); 2243 symbol_debug(sfunc); 2244 2245 assert(sfunc.Sseg); 2246 if (sfunc.Sseg == UNKNOWN) 2247 sfunc.Sseg = CODE; 2248 //printf("sfunc.Sseg %d CODE %d cseg %d Coffset x%x\n",sfunc.Sseg,CODE,cseg,Offset(cseg)); 2249 cseg = sfunc.Sseg; 2250 assert(cseg == CODE || cseg > UDATA); 2251 Obj_pubdef(cseg, sfunc, Offset(cseg)); 2252 sfunc.Soffset = Offset(cseg); 2253 2254 dwarf_func_start(sfunc); 2255 } 2256 2257 /******************************* 2258 * Update function info after codgen 2259 */ 2260 2261 void Obj_func_term(Symbol *sfunc) 2262 { 2263 //dbg_printf("Obj_func_term(%s) offset %x, Coffset %x symidx %d\n", 2264 // sfunc.Sident.ptr, sfunc.Soffset,Offset(cseg),sfunc.Sxtrnnum); 2265 2266 static if (0) 2267 { 2268 // fill in the function size 2269 if (I64) 2270 SymbolTable64[sfunc.Sxtrnnum].st_size = Offset(cseg) - sfunc.Soffset; 2271 else 2272 SymbolTable[sfunc.Sxtrnnum].st_size = Offset(cseg) - sfunc.Soffset; 2273 } 2274 dwarf_func_term(sfunc); 2275 } 2276 2277 /******************************** 2278 * Output a public definition. 2279 * Input: 2280 * seg = segment index that symbol is defined in 2281 * s . symbol 2282 * offset = offset of name within segment 2283 */ 2284 2285 void Obj_pubdefsize(int seg, Symbol *s, targ_size_t offset, targ_size_t symsize) 2286 { 2287 return Obj_pubdef(seg, s, offset); 2288 } 2289 2290 void Obj_pubdef(int seg, Symbol *s, targ_size_t offset) 2291 { 2292 //printf("Obj_pubdef(%d:x%x s=%p, %s)\n", seg, offset, s, s.Sident.ptr); 2293 //symbol_print(s); 2294 symbol_debug(s); 2295 2296 s.Soffset = offset; 2297 s.Sseg = seg; 2298 switch (s.Sclass) 2299 { 2300 case SCglobal: 2301 case SCinline: 2302 public_symbuf.write((&s)[0 .. 1]); 2303 break; 2304 case SCcomdat: 2305 case SCcomdef: 2306 public_symbuf.write((&s)[0 .. 1]); 2307 break; 2308 case SCstatic: 2309 if (s.Sflags & SFLhidden) 2310 { 2311 public_symbuf.write((&s)[0 .. 1]); 2312 break; 2313 } 2314 goto default; 2315 default: 2316 local_symbuf.write((&s)[0 .. 1]); 2317 break; 2318 } 2319 //printf("%p\n", *cast(void**)public_symbuf.buf); 2320 s.Sxtrnnum = 1; 2321 } 2322 2323 /******************************* 2324 * Output an external symbol for name. 2325 * Input: 2326 * name Name to do EXTDEF on 2327 * (Not to be mangled) 2328 * Returns: 2329 * Symbol table index of the definition 2330 * NOTE: Numbers will not be linear. 2331 */ 2332 2333 int Obj_external_def(const(char)* name) 2334 { 2335 //printf("Obj_external_def('%s')\n",name); 2336 assert(name); 2337 assert(extdef == 0); 2338 extdef = Obj_addstr(symtab_strings, name); 2339 return 0; 2340 } 2341 2342 2343 /******************************* 2344 * Output an external for existing symbol. 2345 * Input: 2346 * s Symbol to do EXTDEF on 2347 * (Name is to be mangled) 2348 * Returns: 2349 * Symbol table index of the definition 2350 * NOTE: Numbers will not be linear. 2351 */ 2352 2353 int Obj_external(Symbol *s) 2354 { 2355 //printf("Obj_external('%s') %x\n",s.Sident.ptr,s.Svalue); 2356 symbol_debug(s); 2357 extern_symbuf.write((&s)[0 .. 1]); 2358 s.Sxtrnnum = 1; 2359 return 0; 2360 } 2361 2362 /******************************* 2363 * Output a common block definition. 2364 * Input: 2365 * p . external identifier 2366 * size size in bytes of each elem 2367 * count number of elems 2368 * Returns: 2369 * Symbol table index for symbol 2370 */ 2371 2372 int Obj_common_block(Symbol *s,targ_size_t size,targ_size_t count) 2373 { 2374 //printf("Obj_common_block('%s', size=%d, count=%d)\n",s.Sident.ptr,size,count); 2375 symbol_debug(s); 2376 2377 // can't have code or thread local comdef's 2378 assert(!(s.ty() & (mTYcs | mTYthread))); 2379 // support for hidden comdefs not implemented 2380 assert(!(s.Sflags & SFLhidden)); 2381 2382 Comdef comdef = void; 2383 comdef.sym = s; 2384 comdef.size = size; 2385 comdef.count = cast(int)count; 2386 comdef_symbuf.write(&comdef, (comdef).sizeof); 2387 s.Sxtrnnum = 1; 2388 if (!s.Sseg) 2389 s.Sseg = UDATA; 2390 return 0; // should return void 2391 } 2392 2393 int Obj_common_block(Symbol *s, int flag, targ_size_t size, targ_size_t count) 2394 { 2395 return Obj_common_block(s, size, count); 2396 } 2397 2398 /*************************************** 2399 * Append an iterated data block of 0s. 2400 * (uninitialized data only) 2401 */ 2402 2403 void Obj_write_zeros(seg_data *pseg, targ_size_t count) 2404 { 2405 Obj_lidata(pseg.SDseg, pseg.SDoffset, count); 2406 } 2407 2408 /*************************************** 2409 * Output an iterated data block of 0s. 2410 * 2411 * For boundary alignment and initialization 2412 */ 2413 2414 void Obj_lidata(int seg,targ_size_t offset,targ_size_t count) 2415 { 2416 //printf("Obj_lidata(%d,%x,%d)\n",seg,offset,count); 2417 size_t idx = SegData[seg].SDshtidx; 2418 if ((I64 ? SecHdrTab64[idx].flags : SecHdrTab[idx].flags) == S_ZEROFILL) 2419 { // Use SDoffset to record size of bss section 2420 SegData[seg].SDoffset += count; 2421 } 2422 else 2423 { 2424 Obj_bytes(seg, offset, cast(uint)count, null); 2425 } 2426 } 2427 2428 /*********************************** 2429 * Append byte to segment. 2430 */ 2431 2432 void Obj_write_byte(seg_data *pseg, uint byte_) 2433 { 2434 Obj_byte(pseg.SDseg, pseg.SDoffset, byte_); 2435 } 2436 2437 /************************************ 2438 * Output byte to object file. 2439 */ 2440 2441 void Obj_byte(int seg,targ_size_t offset,uint byte_) 2442 { 2443 Outbuffer *buf = SegData[seg].SDbuf; 2444 int save = cast(int)buf.length(); 2445 //dbg_printf("Obj_byte(seg=%d, offset=x%lx, byte_=x%x)\n",seg,offset,byte_); 2446 buf.setsize(cast(uint)offset); 2447 buf.writeByte(byte_); 2448 if (save > offset+1) 2449 buf.setsize(save); 2450 else 2451 SegData[seg].SDoffset = offset+1; 2452 //dbg_printf("\tsize now %d\n",buf.length()); 2453 } 2454 2455 /*********************************** 2456 * Append bytes to segment. 2457 */ 2458 2459 void Obj_write_bytes(seg_data *pseg, uint nbytes, void *p) 2460 { 2461 Obj_bytes(pseg.SDseg, pseg.SDoffset, nbytes, p); 2462 } 2463 2464 /************************************ 2465 * Output bytes to object file. 2466 * Returns: 2467 * nbytes 2468 */ 2469 2470 uint Obj_bytes(int seg, targ_size_t offset, uint nbytes, void *p) 2471 { 2472 static if (0) 2473 { 2474 if (!(seg >= 0 && seg <= seg_count)) 2475 { printf("Obj_bytes: seg = %d, seg_count = %d\n", seg, seg_count); 2476 *cast(char*)0=0; 2477 } 2478 } 2479 assert(seg >= 0 && seg <= seg_count); 2480 Outbuffer *buf = SegData[seg].SDbuf; 2481 if (buf == null) 2482 { 2483 //dbg_printf("Obj_bytes(seg=%d, offset=x%llx, nbytes=%d, p=%p)\n", seg, offset, nbytes, p); 2484 //raise(SIGSEGV); 2485 assert(buf != null); 2486 } 2487 int save = cast(int)buf.length(); 2488 //dbg_printf("Obj_bytes(seg=%d, offset=x%lx, nbytes=%d, p=x%x)\n", 2489 //seg,offset,nbytes,p); 2490 buf.position(cast(size_t)offset, nbytes); 2491 if (p) 2492 buf.write(p, nbytes); 2493 else // Zero out the bytes 2494 buf.writezeros(nbytes); 2495 2496 if (save > offset+nbytes) 2497 buf.setsize(save); 2498 else 2499 SegData[seg].SDoffset = offset+nbytes; 2500 return nbytes; 2501 } 2502 2503 /********************************************* 2504 * Add a relocation entry for seg/offset. 2505 */ 2506 2507 void Obj_addrel(int seg, targ_size_t offset, Symbol *targsym, 2508 uint targseg, int rtype, int val = 0) 2509 { 2510 Relocation rel = void; 2511 rel.offset = offset; 2512 rel.targsym = targsym; 2513 rel.targseg = targseg; 2514 rel.rtype = cast(ubyte)rtype; 2515 rel.flag = 0; 2516 rel.funcsym = funcsym_p; 2517 rel.val = cast(short)val; 2518 seg_data *pseg = SegData[seg]; 2519 if (!pseg.SDrel) 2520 { 2521 pseg.SDrel = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 2522 assert(pseg.SDrel); 2523 } 2524 pseg.SDrel.write(&rel, rel.sizeof); 2525 } 2526 2527 /******************************* 2528 * Refer to address that is in the data segment. 2529 * Input: 2530 * seg:offset = the address being fixed up 2531 * val = displacement from start of target segment 2532 * targetdatum = target segment number (DATA, CDATA or UDATA, etc.) 2533 * flags = CFoff, CFseg 2534 * Example: 2535 * int *abc = &def[3]; 2536 * to allocate storage: 2537 * Obj_reftodatseg(DATA,offset,3 * (int *).sizeof,UDATA); 2538 */ 2539 2540 void Obj_reftodatseg(int seg,targ_size_t offset,targ_size_t val, 2541 uint targetdatum,int flags) 2542 { 2543 Outbuffer *buf = SegData[seg].SDbuf; 2544 int save = cast(int)buf.length(); 2545 buf.setsize(cast(uint)offset); 2546 static if (0) 2547 { 2548 printf("Obj_reftodatseg(seg:offset=%d:x%llx, val=x%llx, targetdatum %x, flags %x )\n", 2549 seg,offset,val,targetdatum,flags); 2550 } 2551 assert(seg != 0); 2552 if (SegData[seg].isCode() && SegData[targetdatum].isCode()) 2553 { 2554 assert(0); 2555 } 2556 Obj_addrel(seg, offset, null, targetdatum, RELaddr); 2557 if (I64) 2558 { 2559 if (flags & CFoffset64) 2560 { 2561 buf.write64(val); 2562 if (save > offset + 8) 2563 buf.setsize(save); 2564 return; 2565 } 2566 } 2567 buf.write32(cast(int)val); 2568 if (save > offset + 4) 2569 buf.setsize(save); 2570 } 2571 2572 /******************************* 2573 * Refer to address that is in the current function code (funcsym_p). 2574 * Only offsets are output, regardless of the memory model. 2575 * Used to put values in switch address tables. 2576 * Input: 2577 * seg = where the address is going (CODE or DATA) 2578 * offset = offset within seg 2579 * val = displacement from start of this module 2580 */ 2581 2582 void Obj_reftocodeseg(int seg,targ_size_t offset,targ_size_t val) 2583 { 2584 //printf("Obj_reftocodeseg(seg=%d, offset=x%lx, val=x%lx )\n",seg,cast(uint)offset,cast(uint)val); 2585 assert(seg > 0); 2586 Outbuffer *buf = SegData[seg].SDbuf; 2587 int save = cast(int)buf.length(); 2588 buf.setsize(cast(uint)offset); 2589 val -= funcsym_p.Soffset; 2590 Obj_addrel(seg, offset, funcsym_p, 0, RELaddr); 2591 // if (I64) 2592 // buf.write64(val); 2593 // else 2594 buf.write32(cast(int)val); 2595 if (save > offset + 4) 2596 buf.setsize(save); 2597 } 2598 2599 /******************************* 2600 * Refer to an identifier. 2601 * Input: 2602 * seg = where the address is going (CODE or DATA) 2603 * offset = offset within seg 2604 * s . Symbol table entry for identifier 2605 * val = displacement from identifier 2606 * flags = CFselfrel: self-relative 2607 * CFseg: get segment 2608 * CFoff: get offset 2609 * CFpc32: [RIP] addressing, val is 0, -1, -2 or -4 2610 * CFoffset64: 8 byte offset for 64 bit builds 2611 * Returns: 2612 * number of bytes in reference (4 or 8) 2613 */ 2614 2615 int Obj_reftoident(int seg, targ_size_t offset, Symbol *s, targ_size_t val, 2616 int flags) 2617 { 2618 int retsize = (flags & CFoffset64) ? 8 : 4; 2619 static if (0) 2620 { 2621 printf("\nObj_reftoident('%s' seg %d, offset x%llx, val x%llx, flags x%x)\n", 2622 s.Sident.ptr,seg,cast(ulong)offset,cast(ulong)val,flags); 2623 printf("retsize = %d\n", retsize); 2624 //dbg_printf("Sseg = %d, Sxtrnnum = %d\n",s.Sseg,s.Sxtrnnum); 2625 symbol_print(s); 2626 } 2627 assert(seg > 0); 2628 if (s.Sclass != SClocstat && !s.Sxtrnnum) 2629 { // It may get defined later as public or local, so defer 2630 size_t numbyteswritten = addtofixlist(s, offset, seg, val, flags); 2631 assert(numbyteswritten == retsize); 2632 } 2633 else 2634 { 2635 if (I64) 2636 { 2637 //if (s.Sclass != SCcomdat) 2638 //val += s.Soffset; 2639 int v = 0; 2640 if (flags & CFpc32) 2641 v = cast(int)val; 2642 if (flags & CFselfrel) 2643 { 2644 Obj_addrel(seg, offset, s, 0, RELrel, v); 2645 } 2646 else 2647 { 2648 Obj_addrel(seg, offset, s, 0, RELaddr, v); 2649 } 2650 } 2651 else 2652 { 2653 if (SegData[seg].isCode() && flags & CFselfrel) 2654 { 2655 if (!jumpTableSeg) 2656 { 2657 jumpTableSeg = 2658 Obj_getsegment("__jump_table", "__IMPORT", 0, S_SYMBOL_STUBS | S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS | S_ATTR_SELF_MODIFYING_CODE); 2659 } 2660 seg_data *pseg = SegData[jumpTableSeg]; 2661 if (I64) 2662 SecHdrTab64[pseg.SDshtidx].reserved2 = 5; 2663 else 2664 SecHdrTab[pseg.SDshtidx].reserved2 = 5; 2665 2666 if (!indirectsymbuf1) 2667 { 2668 indirectsymbuf1 = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 2669 assert(indirectsymbuf1); 2670 } 2671 else 2672 { // Look through indirectsym to see if it is already there 2673 int n = cast(int)(indirectsymbuf1.length() / (Symbol *).sizeof); 2674 Symbol **psym = cast(Symbol **)indirectsymbuf1.buf; 2675 for (int i = 0; i < n; i++) 2676 { // Linear search, pretty pathetic 2677 if (s == psym[i]) 2678 { val = i * 5; 2679 goto L1; 2680 } 2681 } 2682 } 2683 2684 val = pseg.SDbuf.length(); 2685 static immutable char[5] halts = [ 0xF4,0xF4,0xF4,0xF4,0xF4 ]; 2686 pseg.SDbuf.write(halts.ptr, 5); 2687 2688 // Add symbol s to indirectsymbuf1 2689 indirectsymbuf1.write((&s)[0 .. 1]); 2690 L1: 2691 val -= offset + 4; 2692 Obj_addrel(seg, offset, null, jumpTableSeg, RELrel); 2693 } 2694 else if (SegData[seg].isCode() && 2695 !(flags & CFindirect) && 2696 ((s.Sclass != SCextern && SegData[s.Sseg].isCode()) || s.Sclass == SClocstat || s.Sclass == SCstatic)) 2697 { 2698 val += s.Soffset; 2699 Obj_addrel(seg, offset, null, s.Sseg, RELaddr); 2700 } 2701 else if ((flags & CFindirect) || 2702 SegData[seg].isCode() && !tyfunc(s.ty())) 2703 { 2704 if (!pointersSeg) 2705 { 2706 pointersSeg = 2707 Obj_getsegment("__pointers", "__IMPORT", 0, S_NON_LAZY_SYMBOL_POINTERS); 2708 } 2709 seg_data *pseg = SegData[pointersSeg]; 2710 2711 if (!indirectsymbuf2) 2712 { 2713 indirectsymbuf2 = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 2714 assert(indirectsymbuf2); 2715 } 2716 else 2717 { // Look through indirectsym to see if it is already there 2718 int n = cast(int)(indirectsymbuf2.length() / (Symbol *).sizeof); 2719 Symbol **psym = cast(Symbol **)indirectsymbuf2.buf; 2720 for (int i = 0; i < n; i++) 2721 { // Linear search, pretty pathetic 2722 if (s == psym[i]) 2723 { val = i * 4; 2724 goto L2; 2725 } 2726 } 2727 } 2728 2729 val = pseg.SDbuf.length(); 2730 pseg.SDbuf.writezeros(_tysize[TYnptr]); 2731 2732 // Add symbol s to indirectsymbuf2 2733 indirectsymbuf2.write((&s)[0 .. 1]); 2734 2735 L2: 2736 //printf("Obj_reftoident: seg = %d, offset = x%x, s = %s, val = x%x, pointersSeg = %d\n", seg, (int)offset, s.Sident.ptr, (int)val, pointersSeg); 2737 if (flags & CFindirect) 2738 { 2739 Relocation rel = void; 2740 rel.offset = offset; 2741 rel.targsym = null; 2742 rel.targseg = pointersSeg; 2743 rel.rtype = RELaddr; 2744 rel.flag = 0; 2745 rel.funcsym = null; 2746 rel.val = 0; 2747 seg_data *pseg2 = SegData[seg]; 2748 if (!pseg2.SDrel) 2749 { 2750 pseg2.SDrel = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 2751 assert(pseg2.SDrel); 2752 } 2753 pseg2.SDrel.write(&rel, rel.sizeof); 2754 } 2755 else 2756 Obj_addrel(seg, offset, null, pointersSeg, RELaddr); 2757 } 2758 else 2759 { //val -= s.Soffset; 2760 Obj_addrel(seg, offset, s, 0, RELaddr); 2761 } 2762 } 2763 2764 Outbuffer *buf = SegData[seg].SDbuf; 2765 int save = cast(int)buf.length(); 2766 buf.position(cast(uint)offset, retsize); 2767 //printf("offset = x%llx, val = x%llx\n", offset, val); 2768 if (retsize == 8) 2769 buf.write64(val); 2770 else 2771 buf.write32(cast(int)val); 2772 if (save > offset + retsize) 2773 buf.setsize(save); 2774 } 2775 return retsize; 2776 } 2777 2778 /***************************************** 2779 * Generate far16 thunk. 2780 * Input: 2781 * s Symbol to generate a thunk for 2782 */ 2783 2784 void Obj_far16thunk(Symbol *s) 2785 { 2786 //dbg_printf("Obj_far16thunk('%s')\n", s.Sident.ptr); 2787 assert(0); 2788 } 2789 2790 /************************************** 2791 * Mark object file as using floating point. 2792 */ 2793 2794 void Obj_fltused() 2795 { 2796 //dbg_printf("Obj_fltused()\n"); 2797 } 2798 2799 /************************************ 2800 * Close and delete .OBJ file. 2801 */ 2802 2803 void objfile_delete() 2804 { 2805 //remove(fobjname); // delete corrupt output file 2806 } 2807 2808 /********************************** 2809 * Terminate. 2810 */ 2811 2812 void objfile_term() 2813 { 2814 static if(TERMCODE) 2815 { 2816 mem_free(fobjname); 2817 fobjname = null; 2818 } 2819 } 2820 2821 /********************************** 2822 * Write to the object file 2823 */ 2824 /+void objfile_write(FILE *fd, void *buffer, uint len) 2825 { 2826 fobjbuf.write(buffer, len); 2827 }+/ 2828 2829 int elf_align(targ_size_t size, int foffset) 2830 { 2831 if (size <= 1) 2832 return foffset; 2833 int offset = cast(int)((foffset + size - 1) & ~(size - 1)); 2834 if (offset > foffset) 2835 fobjbuf.writezeros(offset - foffset); 2836 return offset; 2837 } 2838 2839 /*************************************** 2840 * Stuff pointer to ModuleInfo in its own segment. 2841 */ 2842 2843 version (MARS) 2844 { 2845 void Obj_moduleinfo(Symbol *scc) 2846 { 2847 int align_ = I64 ? 3 : 2; // align to _tysize[TYnptr] 2848 2849 int seg = Obj_getsegment("__minfodata", "__DATA", align_, S_REGULAR); 2850 //printf("Obj_moduleinfo(%s) seg = %d:x%x\n", scc.Sident.ptr, seg, Offset(seg)); 2851 2852 static if (0) 2853 { 2854 type *t = type_fake(TYint); 2855 t.Tmangle = mTYman_c; 2856 char *p = cast(char *)malloc(5 + strlen(scc.Sident.ptr) + 1); 2857 strcpy(p, "SUPER"); 2858 strcpy(p + 5, scc.Sident.ptr); 2859 Symbol *s_minfo_beg = symbol_name(p, SCglobal, t); 2860 Obj_pubdef(seg, s_minfo_beg, 0); 2861 } 2862 2863 int flags = CFoff; 2864 if (I64) 2865 flags |= CFoffset64; 2866 SegData[seg].SDoffset += Obj_reftoident(seg, Offset(seg), scc, 0, flags); 2867 } 2868 } 2869 2870 /************************************* 2871 */ 2872 2873 void Obj_gotref(Symbol *s) 2874 { 2875 //printf("Obj_gotref(%x '%s', %d)\n",s,s.Sident.ptr, s.Sclass); 2876 switch(s.Sclass) 2877 { 2878 case SCstatic: 2879 case SClocstat: 2880 s.Sfl = FLgotoff; 2881 break; 2882 2883 case SCextern: 2884 case SCglobal: 2885 case SCcomdat: 2886 case SCcomdef: 2887 s.Sfl = FLgot; 2888 break; 2889 2890 default: 2891 break; 2892 } 2893 } 2894 2895 /** 2896 * Returns the symbol for the __tlv_bootstrap function. 2897 * 2898 * This function is used in the implementation of native thread local storage. 2899 * It's used as a placeholder in the TLV descriptors. The dynamic linker will 2900 * replace the placeholder with a real function at load time. 2901 */ 2902 Symbol* Obj_tlv_bootstrap() 2903 { 2904 __gshared Symbol* tlv_bootstrap_sym; 2905 if (!tlv_bootstrap_sym) 2906 tlv_bootstrap_sym = symbol_name("__tlv_bootstrap", SCextern, type_fake(TYnfunc)); 2907 return tlv_bootstrap_sym; 2908 } 2909 2910 2911 void Obj_write_pointerRef(Symbol* s, uint off) 2912 { 2913 } 2914 2915 /****************************************** 2916 * Generate fixup specific to .eh_frame and .gcc_except_table sections. 2917 * Params: 2918 * seg = segment of where to write fixup 2919 * offset = offset of where to write fixup 2920 * s = fixup is a reference to this Symbol 2921 * val = displacement from s 2922 * Returns: 2923 * number of bytes written at seg:offset 2924 */ 2925 int dwarf_reftoident(int seg, targ_size_t offset, Symbol *s, targ_size_t val) 2926 { 2927 //printf("dwarf_reftoident(seg=%d offset=x%x s=%s val=x%x\n", seg, (int)offset, s.Sident.ptr, (int)val); 2928 Obj_reftoident(seg, offset, s, val + 4, I64 ? CFoff : CFindirect); 2929 return 4; 2930 } 2931 2932 /***************************************** 2933 * Generate LSDA and PC_Begin fixups in the __eh_frame segment encoded as DW_EH_PE_pcrel|ptr. 2934 * 64 bits 2935 * LSDA 2936 * [0] address x0071 symbolnum 6 pcrel 0 length 3 extern 1 type 5 RELOC_SUBTRACTOR __Z3foov.eh 2937 * [1] address x0071 symbolnum 1 pcrel 0 length 3 extern 1 type 0 RELOC_UNSIGNED GCC_except_table2 2938 * PC_Begin: 2939 * [2] address x0060 symbolnum 6 pcrel 0 length 3 extern 1 type 5 RELOC_SUBTRACTOR __Z3foov.eh 2940 * [3] address x0060 symbolnum 5 pcrel 0 length 3 extern 1 type 0 RELOC_UNSIGNED __Z3foov 2941 * Want the result to be &s - pc 2942 * The fixup yields &s - &fdesym + value 2943 * Therefore value = &fdesym - pc 2944 * which is the same as fdesym.Soffset - offset 2945 * 32 bits 2946 * LSDA 2947 * [6] address x0028 pcrel 0 length 2 value x0 type 4 RELOC_LOCAL_SECTDIFF 2948 * [7] address x0000 pcrel 0 length 2 value x1dc type 1 RELOC_PAIR 2949 * PC_Begin 2950 * [8] address x0013 pcrel 0 length 2 value x228 type 4 RELOC_LOCAL_SECTDIFF 2951 * [9] address x0000 pcrel 0 length 2 value x1c7 type 1 RELOC_PAIR 2952 * Params: 2953 * dfseg = segment of where to write fixup (eh_frame segment) 2954 * offset = offset of where to write fixup (eh_frame offset) 2955 * s = fixup is a reference to this Symbol (GCC_except_table%d or function_name) 2956 * val = displacement from s 2957 * fdesym = function_name.eh 2958 * Returns: 2959 * number of bytes written at seg:offset 2960 */ 2961 int dwarf_eh_frame_fixup(int dfseg, targ_size_t offset, Symbol *s, targ_size_t val, Symbol *fdesym) 2962 { 2963 Outbuffer *buf = SegData[dfseg].SDbuf; 2964 assert(offset == buf.length()); 2965 assert(fdesym.Sseg == dfseg); 2966 if (I64) 2967 buf.write64(val); // add in 'value' later 2968 else 2969 buf.write32(cast(int)val); 2970 2971 Relocation rel; 2972 rel.offset = offset; 2973 rel.targsym = s; 2974 rel.targseg = 0; 2975 rel.rtype = RELaddr; 2976 rel.flag = 1; 2977 rel.funcsym = fdesym; 2978 rel.val = 0; 2979 seg_data *pseg = SegData[dfseg]; 2980 if (!pseg.SDrel) 2981 { 2982 pseg.SDrel = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); 2983 assert(pseg.SDrel); 2984 } 2985 pseg.SDrel.write(&rel, rel.sizeof); 2986 2987 return I64 ? 8 : 4; 2988 } 2989 2990 } 2991 }