func adddynrel(ctxt *ld.Link, s *ld.Symbol, r *ld.Reloc) { targ := r.Sym ctxt.Cursym = s switch r.Type { default: if r.Type >= 256 { ctxt.Diag("unexpected relocation type %d", r.Type) return } // Handle relocations found in ELF object files. case 256 + ld.R_ARM_PLT32: r.Type = obj.R_CALLARM if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(braddoff(int32(r.Add), targ.Plt/4)) } return case 256 + ld.R_ARM_THM_PC22: // R_ARM_THM_CALL ld.Exitf("R_ARM_THM_CALL, are you using -marm?") return case 256 + ld.R_ARM_GOT32: // R_ARM_GOT_BREL if targ.Type != obj.SDYNIMPORT { addgotsyminternal(ctxt, targ) } else { addgotsym(ctxt, targ) } r.Type = obj.R_CONST // write r->add during relocsym r.Sym = nil r.Add += int64(targ.Got) return case 256 + ld.R_ARM_GOT_PREL: // GOT(nil) + A - nil if targ.Type != obj.SDYNIMPORT { addgotsyminternal(ctxt, targ) } else { addgotsym(ctxt, targ) } r.Type = obj.R_PCREL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += int64(targ.Got) + 4 return case 256 + ld.R_ARM_GOTOFF: // R_ARM_GOTOFF32 r.Type = obj.R_GOTOFF return case 256 + ld.R_ARM_GOTPC: // R_ARM_BASE_PREL r.Type = obj.R_PCREL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += 4 return case 256 + ld.R_ARM_CALL: r.Type = obj.R_CALLARM if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(braddoff(int32(r.Add), targ.Plt/4)) } return case 256 + ld.R_ARM_REL32: // R_ARM_REL32 r.Type = obj.R_PCREL r.Add += 4 return case 256 + ld.R_ARM_ABS32: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_ARM_ABS32 relocation for dynamic symbol %s", targ.Name) } r.Type = obj.R_ADDR return // we can just ignore this, because we are targeting ARM V5+ anyway case 256 + ld.R_ARM_V4BX: if r.Sym != nil { // R_ARM_V4BX is ABS relocation, so this symbol is a dummy symbol, ignore it r.Sym.Type = 0 } r.Sym = nil return case 256 + ld.R_ARM_PC24, 256 + ld.R_ARM_JUMP24: r.Type = obj.R_CALLARM if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(braddoff(int32(r.Add), targ.Plt/4)) } return } // Handle references to ELF symbols from our own object files. if targ.Type != obj.SDYNIMPORT { return } switch r.Type { case obj.R_CALLARM: addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(targ.Plt) return case obj.R_ADDR: if s.Type != obj.SDATA { break } if ld.Iself { ld.Adddynsym(ctxt, targ) rel := ld.Linklookup(ctxt, ".rel", 0) ld.Addaddrplus(ctxt, rel, s, int64(r.Off)) ld.Adduint32(ctxt, rel, ld.ELF32_R_INFO(uint32(targ.Dynid), ld.R_ARM_GLOB_DAT)) // we need a nil + A dynamic reloc r.Type = obj.R_CONST // write r->add during relocsym r.Sym = nil return } } ctxt.Cursym = s ctxt.Diag("unsupported relocation for dynamic symbol %s (type=%d stype=%d)", targ.Name, r.Type, targ.Type) }
func asmb(ctxt *ld.Link) { if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f asmb\n", obj.Cputime()) } if ld.Iself { ld.Asmbelfsetup(ctxt) } sect := ld.Segtext.Sect ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff)) ld.Codeblk(ctxt, int64(sect.Vaddr), int64(sect.Length)) for sect = sect.Next; sect != nil; sect = sect.Next { ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff)) ld.Datblk(ctxt, int64(sect.Vaddr), int64(sect.Length)) } if ld.Segrodata.Filelen > 0 { if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f rodatblk\n", obj.Cputime()) } ld.Cseek(int64(ld.Segrodata.Fileoff)) ld.Datblk(ctxt, int64(ld.Segrodata.Vaddr), int64(ld.Segrodata.Filelen)) } if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f datblk\n", obj.Cputime()) } ld.Cseek(int64(ld.Segdata.Fileoff)) ld.Datblk(ctxt, int64(ld.Segdata.Vaddr), int64(ld.Segdata.Filelen)) ld.Cseek(int64(ld.Segdwarf.Fileoff)) ld.Dwarfblk(ctxt, int64(ld.Segdwarf.Vaddr), int64(ld.Segdwarf.Filelen)) /* output symbol table */ ld.Symsize = 0 ld.Lcsize = 0 symo := uint32(0) if !*ld.FlagS { // TODO: rationalize if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f sym\n", obj.Cputime()) } switch ld.HEADTYPE { default: if ld.Iself { symo = uint32(ld.Segdwarf.Fileoff + ld.Segdwarf.Filelen) symo = uint32(ld.Rnd(int64(symo), int64(*ld.FlagRound))) } case obj.Hplan9: symo = uint32(ld.Segdata.Fileoff + ld.Segdata.Filelen) } ld.Cseek(int64(symo)) switch ld.HEADTYPE { default: if ld.Iself { if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f elfsym\n", obj.Cputime()) } ld.Asmelfsym(ctxt) ld.Cflush() ld.Cwrite(ld.Elfstrdat) if ld.Linkmode == ld.LinkExternal { ld.Elfemitreloc(ctxt) } } case obj.Hplan9: ld.Asmplan9sym(ctxt) ld.Cflush() sym := ld.Linklookup(ctxt, "pclntab", 0) if sym != nil { ld.Lcsize = int32(len(sym.P)) for i := 0; int32(i) < ld.Lcsize; i++ { ld.Cput(sym.P[i]) } ld.Cflush() } } } ctxt.Cursym = nil if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f header\n", obj.Cputime()) } ld.Cseek(0) switch ld.HEADTYPE { default: case obj.Hplan9: /* plan 9 */ magic := uint32(4*18*18 + 7) if ld.SysArch == sys.ArchMIPS64LE { magic = uint32(4*26*26 + 7) } ld.Thearch.Lput(magic) /* magic */ ld.Thearch.Lput(uint32(ld.Segtext.Filelen)) /* sizes */ ld.Thearch.Lput(uint32(ld.Segdata.Filelen)) ld.Thearch.Lput(uint32(ld.Segdata.Length - ld.Segdata.Filelen)) ld.Thearch.Lput(uint32(ld.Symsize)) /* nsyms */ ld.Thearch.Lput(uint32(ld.Entryvalue(ctxt))) /* va of entry */ ld.Thearch.Lput(0) ld.Thearch.Lput(uint32(ld.Lcsize)) case obj.Hlinux, obj.Hfreebsd, obj.Hnetbsd, obj.Hopenbsd, obj.Hnacl: ld.Asmbelf(ctxt, int64(symo)) } ld.Cflush() if *ld.FlagC { fmt.Printf("textsize=%d\n", ld.Segtext.Filelen) fmt.Printf("datsize=%d\n", ld.Segdata.Filelen) fmt.Printf("bsssize=%d\n", ld.Segdata.Length-ld.Segdata.Filelen) fmt.Printf("symsize=%d\n", ld.Symsize) fmt.Printf("lcsize=%d\n", ld.Lcsize) fmt.Printf("total=%d\n", ld.Segtext.Filelen+ld.Segdata.Length+uint64(ld.Symsize)+uint64(ld.Lcsize)) } }
func adddynrel(ctxt *ld.Link, s *ld.Symbol, r *ld.Reloc) { targ := r.Sym ctxt.Cursym = s switch r.Type { default: if r.Type >= 256 { ctxt.Diag("unexpected relocation type %d", r.Type) return } // Handle relocations found in ELF object files. case 256 + ld.R_386_PC32: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_386_PC32 relocation for dynamic symbol %s", targ.Name) } if targ.Type == 0 || targ.Type == obj.SXREF { ctxt.Diag("unknown symbol %s in pcrel", targ.Name) } r.Type = obj.R_PCREL r.Add += 4 return case 256 + ld.R_386_PLT32: r.Type = obj.R_PCREL r.Add += 4 if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add += int64(targ.Plt) } return case 256 + ld.R_386_GOT32, 256 + ld.R_386_GOT32X: if targ.Type != obj.SDYNIMPORT { // have symbol if r.Off >= 2 && s.P[r.Off-2] == 0x8b { // turn MOVL of GOT entry into LEAL of symbol address, relative to GOT. s.P[r.Off-2] = 0x8d r.Type = obj.R_GOTOFF return } if r.Off >= 2 && s.P[r.Off-2] == 0xff && s.P[r.Off-1] == 0xb3 { // turn PUSHL of GOT entry into PUSHL of symbol itself. // use unnecessary SS prefix to keep instruction same length. s.P[r.Off-2] = 0x36 s.P[r.Off-1] = 0x68 r.Type = obj.R_ADDR return } ctxt.Diag("unexpected GOT reloc for non-dynamic symbol %s", targ.Name) return } addgotsym(ctxt, targ) r.Type = obj.R_CONST // write r->add during relocsym r.Sym = nil r.Add += int64(targ.Got) return case 256 + ld.R_386_GOTOFF: r.Type = obj.R_GOTOFF return case 256 + ld.R_386_GOTPC: r.Type = obj.R_PCREL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += 4 return case 256 + ld.R_386_32: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_386_32 relocation for dynamic symbol %s", targ.Name) } r.Type = obj.R_ADDR return case 512 + ld.MACHO_GENERIC_RELOC_VANILLA*2 + 0: r.Type = obj.R_ADDR if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected reloc for dynamic symbol %s", targ.Name) } return case 512 + ld.MACHO_GENERIC_RELOC_VANILLA*2 + 1: if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(targ.Plt) r.Type = obj.R_PCREL return } r.Type = obj.R_PCREL return case 512 + ld.MACHO_FAKE_GOTPCREL: if targ.Type != obj.SDYNIMPORT { // have symbol // turn MOVL of GOT entry into LEAL of symbol itself if r.Off < 2 || s.P[r.Off-2] != 0x8b { ctxt.Diag("unexpected GOT reloc for non-dynamic symbol %s", targ.Name) return } s.P[r.Off-2] = 0x8d r.Type = obj.R_PCREL return } addgotsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += int64(targ.Got) r.Type = obj.R_PCREL return } // Handle references to ELF symbols from our own object files. if targ.Type != obj.SDYNIMPORT { return } switch r.Type { case obj.R_CALL, obj.R_PCREL: addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(targ.Plt) return case obj.R_ADDR: if s.Type != obj.SDATA { break } if ld.Iself { ld.Adddynsym(ctxt, targ) rel := ld.Linklookup(ctxt, ".rel", 0) ld.Addaddrplus(ctxt, rel, s, int64(r.Off)) ld.Adduint32(ctxt, rel, ld.ELF32_R_INFO(uint32(targ.Dynid), ld.R_386_32)) r.Type = obj.R_CONST // write r->add during relocsym r.Sym = nil return } if ld.HEADTYPE == obj.Hdarwin && s.Size == int64(ld.SysArch.PtrSize) && r.Off == 0 { // Mach-O relocations are a royal pain to lay out. // They use a compact stateful bytecode representation // that is too much bother to deal with. // Instead, interpret the C declaration // void *_Cvar_stderr = &stderr; // as making _Cvar_stderr the name of a GOT entry // for stderr. This is separate from the usual GOT entry, // just in case the C code assigns to the variable, // and of course it only works for single pointers, // but we only need to support cgo and that's all it needs. ld.Adddynsym(ctxt, targ) got := ld.Linklookup(ctxt, ".got", 0) s.Type = got.Type | obj.SSUB s.Outer = got s.Sub = got.Sub got.Sub = s s.Value = got.Size ld.Adduint32(ctxt, got, 0) ld.Adduint32(ctxt, ld.Linklookup(ctxt, ".linkedit.got", 0), uint32(targ.Dynid)) r.Type = 256 // ignore during relocsym return } if ld.HEADTYPE == obj.Hwindows && s.Size == int64(ld.SysArch.PtrSize) { // nothing to do, the relocation will be laid out in pereloc1 return } } ctxt.Cursym = s ctxt.Diag("unsupported relocation for dynamic symbol %s (type=%d stype=%d)", targ.Name, r.Type, targ.Type) }
func asmb(ctxt *ld.Link) { if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f asmb\n", obj.Cputime()) } if ld.Iself { ld.Asmbelfsetup(ctxt) } sect := ld.Segtext.Sect ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff)) ld.Codeblk(ctxt, int64(sect.Vaddr), int64(sect.Length)) for sect = sect.Next; sect != nil; sect = sect.Next { ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff)) ld.Datblk(ctxt, int64(sect.Vaddr), int64(sect.Length)) } if ld.Segrodata.Filelen > 0 { if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f rodatblk\n", obj.Cputime()) } ld.Cseek(int64(ld.Segrodata.Fileoff)) ld.Datblk(ctxt, int64(ld.Segrodata.Vaddr), int64(ld.Segrodata.Filelen)) } if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f datblk\n", obj.Cputime()) } ld.Cseek(int64(ld.Segdata.Fileoff)) ld.Datblk(ctxt, int64(ld.Segdata.Vaddr), int64(ld.Segdata.Filelen)) ld.Cseek(int64(ld.Segdwarf.Fileoff)) ld.Dwarfblk(ctxt, int64(ld.Segdwarf.Vaddr), int64(ld.Segdwarf.Filelen)) /* output symbol table */ ld.Symsize = 0 ld.Lcsize = 0 symo := uint32(0) if !*ld.FlagS { if !ld.Iself { ctxt.Diag("unsupported executable format") } if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f sym\n", obj.Cputime()) } symo = uint32(ld.Segdwarf.Fileoff + ld.Segdwarf.Filelen) symo = uint32(ld.Rnd(int64(symo), int64(*ld.FlagRound))) ld.Cseek(int64(symo)) if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f elfsym\n", obj.Cputime()) } ld.Asmelfsym(ctxt) ld.Cflush() ld.Cwrite(ld.Elfstrdat) if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f dwarf\n", obj.Cputime()) } if ld.Linkmode == ld.LinkExternal { ld.Elfemitreloc(ctxt) } } ctxt.Cursym = nil if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f header\n", obj.Cputime()) } ld.Cseek(0) switch ld.HEADTYPE { default: ctxt.Diag("unsupported operating system") case obj.Hlinux: ld.Asmbelf(ctxt, int64(symo)) } ld.Cflush() if *ld.FlagC { fmt.Printf("textsize=%d\n", ld.Segtext.Filelen) fmt.Printf("datsize=%d\n", ld.Segdata.Filelen) fmt.Printf("bsssize=%d\n", ld.Segdata.Length-ld.Segdata.Filelen) fmt.Printf("symsize=%d\n", ld.Symsize) fmt.Printf("lcsize=%d\n", ld.Lcsize) fmt.Printf("total=%d\n", ld.Segtext.Filelen+ld.Segdata.Length+uint64(ld.Symsize)+uint64(ld.Lcsize)) } }
func adddynrel(ctxt *ld.Link, s *ld.Symbol, r *ld.Reloc) { targ := r.Sym ctxt.Cursym = s switch r.Type { default: if r.Type >= 256 { ctxt.Diag("unexpected relocation type %d", r.Type) return } // Handle relocations found in ELF object files. case 256 + ld.R_390_12, 256 + ld.R_390_GOT12: ctxt.Diag("s390x 12-bit relocations have not been implemented (relocation type %d)", r.Type-256) return case 256 + ld.R_390_8, 256 + ld.R_390_16, 256 + ld.R_390_32, 256 + ld.R_390_64: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_390_nn relocation for dynamic symbol %s", targ.Name) } r.Type = obj.R_ADDR return case 256 + ld.R_390_PC16, 256 + ld.R_390_PC32, 256 + ld.R_390_PC64: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_390_PCnn relocation for dynamic symbol %s", targ.Name) } if targ.Type == 0 || targ.Type == obj.SXREF { ctxt.Diag("unknown symbol %s in pcrel", targ.Name) } r.Type = obj.R_PCREL r.Add += int64(r.Siz) return case 256 + ld.R_390_GOT16, 256 + ld.R_390_GOT32, 256 + ld.R_390_GOT64: ctxt.Diag("unimplemented S390x relocation: %v", r.Type-256) return case 256 + ld.R_390_PLT16DBL, 256 + ld.R_390_PLT32DBL: r.Type = obj.R_PCREL r.Variant = ld.RV_390_DBL r.Add += int64(r.Siz) if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add += int64(targ.Plt) } return case 256 + ld.R_390_PLT32, 256 + ld.R_390_PLT64: r.Type = obj.R_PCREL r.Add += int64(r.Siz) if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add += int64(targ.Plt) } return case 256 + ld.R_390_COPY: ctxt.Diag("unimplemented S390x relocation: %v", r.Type-256) case 256 + ld.R_390_GLOB_DAT: ctxt.Diag("unimplemented S390x relocation: %v", r.Type-256) case 256 + ld.R_390_JMP_SLOT: ctxt.Diag("unimplemented S390x relocation: %v", r.Type-256) case 256 + ld.R_390_RELATIVE: ctxt.Diag("unimplemented S390x relocation: %v", r.Type-256) case 256 + ld.R_390_GOTOFF: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_390_GOTOFF relocation for dynamic symbol %s", targ.Name) } r.Type = obj.R_GOTOFF return case 256 + ld.R_390_GOTPC: r.Type = obj.R_PCREL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += int64(r.Siz) return case 256 + ld.R_390_PC16DBL, 256 + ld.R_390_PC32DBL: r.Type = obj.R_PCREL r.Variant = ld.RV_390_DBL r.Add += int64(r.Siz) if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_390_PCnnDBL relocation for dynamic symbol %s", targ.Name) } return case 256 + ld.R_390_GOTPCDBL: r.Type = obj.R_PCREL r.Variant = ld.RV_390_DBL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += int64(r.Siz) return case 256 + ld.R_390_GOTENT: addgotsym(ctxt, targ) r.Type = obj.R_PCREL r.Variant = ld.RV_390_DBL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += int64(targ.Got) r.Add += int64(r.Siz) return } // Handle references to ELF symbols from our own object files. if targ.Type != obj.SDYNIMPORT { return } ctxt.Diag("unsupported relocation for dynamic symbol %s (type=%d stype=%d)", targ.Name, r.Type, targ.Type) }
func adddynrel(ctxt *ld.Link, s *ld.Symbol, r *ld.Reloc) { targ := r.Sym ctxt.Cursym = s switch r.Type { default: if r.Type >= 256 { ctxt.Diag("unexpected relocation type %d", r.Type) return } // Handle relocations found in ELF object files. case 256 + ld.R_X86_64_PC32: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_X86_64_PC32 relocation for dynamic symbol %s", targ.Name) } if targ.Type == 0 || targ.Type == obj.SXREF { ctxt.Diag("unknown symbol %s in pcrel", targ.Name) } r.Type = obj.R_PCREL r.Add += 4 return case 256 + ld.R_X86_64_PLT32: r.Type = obj.R_PCREL r.Add += 4 if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add += int64(targ.Plt) } return case 256 + ld.R_X86_64_GOTPCREL, 256 + ld.R_X86_64_GOTPCRELX, 256 + ld.R_X86_64_REX_GOTPCRELX: if targ.Type != obj.SDYNIMPORT { // have symbol if r.Off >= 2 && s.P[r.Off-2] == 0x8b { // turn MOVQ of GOT entry into LEAQ of symbol itself s.P[r.Off-2] = 0x8d r.Type = obj.R_PCREL r.Add += 4 return } } // fall back to using GOT and hope for the best (CMOV*) // TODO: just needs relocation, no need to put in .dynsym addgotsym(ctxt, targ) r.Type = obj.R_PCREL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += 4 r.Add += int64(targ.Got) return case 256 + ld.R_X86_64_64: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_X86_64_64 relocation for dynamic symbol %s", targ.Name) } r.Type = obj.R_ADDR return // Handle relocations found in Mach-O object files. case 512 + ld.MACHO_X86_64_RELOC_UNSIGNED*2 + 0, 512 + ld.MACHO_X86_64_RELOC_SIGNED*2 + 0, 512 + ld.MACHO_X86_64_RELOC_BRANCH*2 + 0: // TODO: What is the difference between all these? r.Type = obj.R_ADDR if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected reloc for dynamic symbol %s", targ.Name) } return case 512 + ld.MACHO_X86_64_RELOC_BRANCH*2 + 1: if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(targ.Plt) r.Type = obj.R_PCREL return } fallthrough // fall through case 512 + ld.MACHO_X86_64_RELOC_UNSIGNED*2 + 1, 512 + ld.MACHO_X86_64_RELOC_SIGNED*2 + 1, 512 + ld.MACHO_X86_64_RELOC_SIGNED_1*2 + 1, 512 + ld.MACHO_X86_64_RELOC_SIGNED_2*2 + 1, 512 + ld.MACHO_X86_64_RELOC_SIGNED_4*2 + 1: r.Type = obj.R_PCREL if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected pc-relative reloc for dynamic symbol %s", targ.Name) } return case 512 + ld.MACHO_X86_64_RELOC_GOT_LOAD*2 + 1: if targ.Type != obj.SDYNIMPORT { // have symbol // turn MOVQ of GOT entry into LEAQ of symbol itself if r.Off < 2 || s.P[r.Off-2] != 0x8b { ctxt.Diag("unexpected GOT_LOAD reloc for non-dynamic symbol %s", targ.Name) return } s.P[r.Off-2] = 0x8d r.Type = obj.R_PCREL return } fallthrough // fall through case 512 + ld.MACHO_X86_64_RELOC_GOT*2 + 1: if targ.Type != obj.SDYNIMPORT { ctxt.Diag("unexpected GOT reloc for non-dynamic symbol %s", targ.Name) } addgotsym(ctxt, targ) r.Type = obj.R_PCREL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += int64(targ.Got) return } // Handle references to ELF symbols from our own object files. if targ.Type != obj.SDYNIMPORT { return } switch r.Type { case obj.R_CALL, obj.R_PCREL: if ld.HEADTYPE == obj.Hwindows { // nothing to do, the relocation will be laid out in pereloc1 return } else { // for both ELF and Mach-O addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(targ.Plt) return } case obj.R_ADDR: if s.Type == obj.STEXT && ld.Iself { if ld.HEADTYPE == obj.Hsolaris { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add += int64(targ.Plt) return } // The code is asking for the address of an external // function. We provide it with the address of the // correspondent GOT symbol. addgotsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += int64(targ.Got) return } if s.Type != obj.SDATA { break } if ld.Iself { ld.Adddynsym(ctxt, targ) rela := ld.Linklookup(ctxt, ".rela", 0) ld.Addaddrplus(ctxt, rela, s, int64(r.Off)) if r.Siz == 8 { ld.Adduint64(ctxt, rela, ld.ELF64_R_INFO(uint32(targ.Dynid), ld.R_X86_64_64)) } else { ld.Adduint64(ctxt, rela, ld.ELF64_R_INFO(uint32(targ.Dynid), ld.R_X86_64_32)) } ld.Adduint64(ctxt, rela, uint64(r.Add)) r.Type = 256 // ignore during relocsym return } if ld.HEADTYPE == obj.Hdarwin && s.Size == int64(ld.SysArch.PtrSize) && r.Off == 0 { // Mach-O relocations are a royal pain to lay out. // They use a compact stateful bytecode representation // that is too much bother to deal with. // Instead, interpret the C declaration // void *_Cvar_stderr = &stderr; // as making _Cvar_stderr the name of a GOT entry // for stderr. This is separate from the usual GOT entry, // just in case the C code assigns to the variable, // and of course it only works for single pointers, // but we only need to support cgo and that's all it needs. ld.Adddynsym(ctxt, targ) got := ld.Linklookup(ctxt, ".got", 0) s.Type = got.Type | obj.SSUB s.Outer = got s.Sub = got.Sub got.Sub = s s.Value = got.Size ld.Adduint64(ctxt, got, 0) ld.Adduint32(ctxt, ld.Linklookup(ctxt, ".linkedit.got", 0), uint32(targ.Dynid)) r.Type = 256 // ignore during relocsym return } if ld.HEADTYPE == obj.Hwindows { // nothing to do, the relocation will be laid out in pereloc1 return } } ctxt.Cursym = s ctxt.Diag("unsupported relocation for dynamic symbol %s (type=%d stype=%d)", targ.Name, r.Type, targ.Type) }
func adddynrel(ctxt *ld.Link, s *ld.Symbol, r *ld.Reloc) { targ := r.Sym ctxt.Cursym = s switch r.Type { default: if r.Type >= 256 { ctxt.Diag("unexpected relocation type %d", r.Type) return } // Handle relocations found in ELF object files. case 256 + ld.R_PPC64_REL24: r.Type = obj.R_CALLPOWER // This is a local call, so the caller isn't setting // up r12 and r2 is the same for the caller and // callee. Hence, we need to go to the local entry // point. (If we don't do this, the callee will try // to use r12 to compute r2.) r.Add += int64(r.Sym.Localentry) * 4 if targ.Type == obj.SDYNIMPORT { // Should have been handled in elfsetupplt ctxt.Diag("unexpected R_PPC64_REL24 for dyn import") } return case 256 + ld.R_PPC_REL32: r.Type = obj.R_PCREL r.Add += 4 if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_PPC_REL32 for dyn import") } return case 256 + ld.R_PPC64_ADDR64: r.Type = obj.R_ADDR if targ.Type == obj.SDYNIMPORT { // These happen in .toc sections ld.Adddynsym(ctxt, targ) rela := ld.Linklookup(ctxt, ".rela", 0) ld.Addaddrplus(ctxt, rela, s, int64(r.Off)) ld.Adduint64(ctxt, rela, ld.ELF64_R_INFO(uint32(targ.Dynid), ld.R_PPC64_ADDR64)) ld.Adduint64(ctxt, rela, uint64(r.Add)) r.Type = 256 // ignore during relocsym } return case 256 + ld.R_PPC64_TOC16: r.Type = obj.R_POWER_TOC r.Variant = ld.RV_POWER_LO | ld.RV_CHECK_OVERFLOW return case 256 + ld.R_PPC64_TOC16_LO: r.Type = obj.R_POWER_TOC r.Variant = ld.RV_POWER_LO return case 256 + ld.R_PPC64_TOC16_HA: r.Type = obj.R_POWER_TOC r.Variant = ld.RV_POWER_HA | ld.RV_CHECK_OVERFLOW return case 256 + ld.R_PPC64_TOC16_HI: r.Type = obj.R_POWER_TOC r.Variant = ld.RV_POWER_HI | ld.RV_CHECK_OVERFLOW return case 256 + ld.R_PPC64_TOC16_DS: r.Type = obj.R_POWER_TOC r.Variant = ld.RV_POWER_DS | ld.RV_CHECK_OVERFLOW return case 256 + ld.R_PPC64_TOC16_LO_DS: r.Type = obj.R_POWER_TOC r.Variant = ld.RV_POWER_DS return case 256 + ld.R_PPC64_REL16_LO: r.Type = obj.R_PCREL r.Variant = ld.RV_POWER_LO r.Add += 2 // Compensate for relocation size of 2 return case 256 + ld.R_PPC64_REL16_HI: r.Type = obj.R_PCREL r.Variant = ld.RV_POWER_HI | ld.RV_CHECK_OVERFLOW r.Add += 2 return case 256 + ld.R_PPC64_REL16_HA: r.Type = obj.R_PCREL r.Variant = ld.RV_POWER_HA | ld.RV_CHECK_OVERFLOW r.Add += 2 return } // Handle references to ELF symbols from our own object files. if targ.Type != obj.SDYNIMPORT { return } // TODO(austin): Translate our relocations to ELF ctxt.Diag("unsupported relocation for dynamic symbol %s (type=%d stype=%d)", targ.Name, r.Type, targ.Type) }