freepascal.compiler/compiler/i386/cpuelf.pas

{
    Copyright (c) 1998-2006 by Peter Vreman

    Includes ELF-related code specific to i386

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 ****************************************************************************
}
unit cpuelf;

{$i fpcdefs.inc}

interface

implementation

  uses
    globtype,cclasses,
    verbose,
    systems,ogbase,ogelf,assemble;

  type
    TElfTarget386=class(TElfTarget)
      class function encodereloc(objrel:TObjRelocation):byte;override;
      class procedure loadreloc(objrel:TObjRelocation);override;
    end;

    TElfExeOutput386=class(TElfExeOutput)
    private
      procedure MaybeWriteGOTEntry(reltyp:byte;relocval:aint;objsym:TObjSymbol);
    protected
      procedure WriteFirstPLTEntry;override;
      procedure WritePLTEntry(exesym:TExeSymbol);override;
      procedure WriteIndirectPLTEntry(exesym:TExeSymbol);override;
      procedure GOTRelocPass1(objsec:TObjSection;ObjReloc:TObjRelocation);override;
      procedure DoRelocationFixup(objsec:TObjSection);override;
    end;

  const
    { Relocation types }
    R_386_NONE = 0;
    R_386_32 = 1;                    { ordinary absolute relocation }
    R_386_PC32 = 2;                  { PC-relative relocation }
    R_386_GOT32 = 3;                 { an offset into GOT }
    R_386_PLT32 = 4;                 { a PC-relative offset into PLT }
    R_386_COPY = 5;
    R_386_GLOB_DAT = 6;
    R_386_JUMP_SLOT = 7;
    R_386_RELATIVE = 8;
    R_386_GOTOFF = 9;                { an offset from GOT base }
    R_386_GOTPC = 10;                { a PC-relative offset _to_ GOT }

    R_386_TLS_TPOFF = 14;
    R_386_TLS_IE = 15;
    R_386_TLS_GOTIE = 16;
    R_386_TLS_LE = 17;
    R_386_TLS_GD = 18;
    R_386_TLS_LDM = 19;
    R_386_16 = 20;
    R_386_PC16 = 21;
    R_386_8 = 22;
    R_386_PC8 = 23;
    R_386_TLS_GD_32 = 24;
    R_386_TLS_GD_PUSH = 25;
    R_386_TLS_GD_CALL = 26;
    R_386_TLS_GD_POP = 27;
    R_386_TLS_LDM_32 = 28;
    R_386_TLS_LDM_PUSH = 29;
    R_386_TLS_LDM_CALL = 30;
    R_386_TLS_LDM_POP = 31;
    R_386_TLS_LDO_32 = 32;
    R_386_TLS_IE_32 = 33;
    R_386_TLS_LE_32 = 34;
    R_386_TLS_DTPMOD32 = 35;
    R_386_TLS_DTPOFF32 = 36;
    R_386_TLS_TPOFF32 = 37;
    { 38 is unused }
    R_386_TLS_GOTDESC = 39;
    R_386_TLS_DESC_CALL = 40;
    R_386_TLS_DESC = 41;
    R_386_IRELATIVE = 42;
    R_386_GNU_VTINHERIT = 250;
    R_386_GNU_VTENTRY = 251;


{****************************************************************************
                               TElfTarget386
****************************************************************************}

  class function TElfTarget386.encodereloc(objrel:TObjRelocation):byte;
    begin
      case objrel.typ of
        RELOC_NONE :
          result:=R_386_NONE;
        RELOC_RELATIVE :
          result:=R_386_PC32;
        RELOC_ABSOLUTE :
          result:=R_386_32;
        RELOC_GOT32 :
          result:=R_386_GOT32;
        RELOC_GOTPC :
          result:=R_386_GOTPC;
        RELOC_PLT32 :
          result:=R_386_PLT32;
      else
        result:=0;
        InternalError(2012082301);
      end;
    end;


  class procedure TElfTarget386.loadreloc(objrel:TObjRelocation);
    begin
    end;


{****************************************************************************
                               TElfExeOutput386
****************************************************************************}


  procedure TElfExeOutput386.WriteFirstPLTEntry;
    begin
      if IsSharedLibrary then
        // push 4(%ebx);  jmp  *8(%ebx)
        pltobjsec.writeBytes(#$FF#$B3#$04#$00#$00#$00#$FF#$A3#$08#$00#$00#$00)
      else
        begin
          pltobjsec.writeBytes(#$FF#$35);         // push got+4
          pltobjsec.writeReloc_internal(gotpltobjsec,sizeof(pint),4,RELOC_ABSOLUTE);
          pltobjsec.writeBytes(#$FF#$25);         // jmp  *got+8
          pltobjsec.writeReloc_internal(gotpltobjsec,2*sizeof(pint),4,RELOC_ABSOLUTE);
        end;
      pltobjsec.writeBytes(#$90#$90#$90#$90);     // nop
    end;


  procedure TElfExeOutput386.WritePLTEntry(exesym:TExeSymbol);
    var
      got_offset: aword;
      tmp:pint;
    begin
      got_offset:=gotpltobjsec.size;
      if IsSharedLibrary then
        begin
          pltobjsec.writeBytes(#$FF#$A3);   // jmp got+x(%ebx)
          pltobjsec.write(got_offset,4);
        end
      else
        begin
          pltobjsec.writeBytes(#$FF#$25);   // jmp *got+x
          pltobjsec.writeReloc_internal(gotpltobjsec,got_offset,4,RELOC_ABSOLUTE);
        end;
      pltobjsec.writeBytes(#$68);           // push  $index
      tmp:=pltrelocsec.size;
      pltobjsec.write(tmp,4);

      pltobjsec.writeBytes(#$E9);           // jmp   .plt
      tmp:=-(4+pltobjsec.Size);
      pltobjsec.write(tmp,4);

      { write a .got.plt slot pointing back to the 'push' instruction }
      gotpltobjsec.writeReloc_internal(pltobjsec,pltobjsec.size-(16-6),sizeof(pint),RELOC_ABSOLUTE);

      { write a .rel.plt entry }
      pltrelocsec.writeReloc_internal(gotpltobjsec,got_offset,sizeof(pint),RELOC_ABSOLUTE);
      got_offset:=(exesym.dynindex shl 8) or R_386_JUMP_SLOT;
      pltrelocsec.write(got_offset,sizeof(pint));
      if relocs_use_addend then
        pltrelocsec.writezeros(sizeof(pint));
    end;


  procedure TElfExeOutput386.WriteIndirectPLTEntry(exesym:TExeSymbol);
    begin
      // TODO
      inherited WriteIndirectPLTEntry(exesym);
    end;


  procedure TElfExeOutput386.GOTRelocPass1(objsec:TObjSection;ObjReloc:TObjRelocation);
    var
      objsym:TObjSymbol;
      sym:TExeSymbol;
      reltyp:byte;
    begin
      if (ObjReloc.flags and rf_raw)=0 then
        reltyp:=ElfTarget.encodereloc(ObjReloc)
      else
        reltyp:=ObjReloc.ftype;
      case reltyp of

        R_386_PLT32:
          begin
            objsym:=objreloc.symbol.exesymbol.ObjSymbol;
            objsym.refs:=objsym.refs or symref_plt;
          end;

        R_386_TLS_IE,
        R_386_GOT32:
          begin
            sym:=ObjReloc.symbol.exesymbol;

            { Although local symbols should not be accessed through GOT,
              this isn't strictly forbidden. In this case we need to fake up
              the exesym to store the GOT offset in it.
              TODO: name collision; maybe use a different symbol list object? }
            if sym=nil then
              begin
                sym:=TExeSymbol.Create(ExeSymbolList,objreloc.symbol.name+'*local*');
                sym.objsymbol:=objreloc.symbol;
                objreloc.symbol.exesymbol:=sym;
              end;
            if sym.GotOffset>0 then
              exit;
            gotobjsec.alloc(sizeof(pint));
            sym.GotOffset:=gotobjsec.size;
            { In shared library, every GOT entry needs a RELATIVE dynamic reloc,
              imported/exported symbols need GLOB_DAT instead. For executables,
              only the latter applies. }
            if IsSharedLibrary or (sym.dynindex>0) then
              dynrelocsec.alloc(dynrelocsec.shentsize);
          end;

        R_386_32:
          begin
            { TODO: How to handle absolute relocation to *weak* external symbol
              from executable? See test/tweaklib2, symbol test2, ld handles it
              differently for PIC and non-PIC code. In non-PIC code it drops
              dynamic relocation altogether. }
            if not IsSharedLibrary then
              exit;
            if (oso_executable in objsec.SecOptions) or
               not (oso_write in objsec.SecOptions) then
              hastextrelocs:=True;
            dynrelocsec.alloc(dynrelocsec.shentsize);
            objreloc.flags:=objreloc.flags or rf_dynamic;
          end;

        R_386_PC32:
          begin
            if not IsSharedLibrary then
              exit;
            { In shared library PC32 reloc to external symbol cannot be redirected
              to PLT entry, because PIC PLT relies on ebx register set properly. }
            if assigned(objreloc.symbol) and
              (
                (objreloc.symbol.objsection=nil) or
                (oso_plt in objreloc.symbol.objsection.SecOptions)
              ) then
              begin
                { Must be a dynamic symbol }
                if not (assigned(objreloc.symbol.exesymbol) and
                   (objreloc.symbol.exesymbol.dynindex<>0)) then
                  InternalError(2012101201);
                if (oso_executable in objsec.SecOptions) or
                  not (oso_write in objsec.SecOptions) then
                  hastextrelocs:=True;
                dynrelocsec.alloc(dynrelocsec.shentsize);
                objreloc.flags:=objreloc.flags or rf_dynamic;
              end;
          end;
      end;
    end;


  procedure TElfExeOutput386.MaybeWriteGOTEntry(reltyp:byte;relocval:aint;objsym:TObjSymbol);
    var
      gotoff,tmp:aword;
    begin
      gotoff:=objsym.exesymbol.gotoffset;
      if gotoff=0 then
        InternalError(2012060902);

      { the GOT slot itself, and a dynamic relocation for it }
      { TODO: only data symbols must get here }
      if gotoff=gotobjsec.Data.size+sizeof(pint) then
        begin
          gotobjsec.write(relocval,sizeof(pint));

          tmp:=gotobjsec.mempos+gotoff-sizeof(pint);
          if (objsym.exesymbol.dynindex>0) then
            begin
              if (reltyp=R_386_TLS_IE) then
                if IsSharedLibrary then
                  WriteDynRelocEntry(tmp,R_386_TLS_TPOFF,objsym.exesymbol.dynindex,0)
                else
              else
                WriteDynRelocEntry(tmp,R_386_GLOB_DAT,objsym.exesymbol.dynindex,0)
            end
          else if IsSharedLibrary then
            WriteDynRelocEntry(tmp,R_386_RELATIVE,0,relocval);
        end;
    end;


  procedure TElfExeOutput386.DoRelocationFixup(objsec:TObjSection);
    var
      i,zero:longint;
      objreloc: TObjRelocation;
      address,
      relocval : aint;
      relocsec : TObjSection;
      data: TDynamicArray;
      reltyp: byte;
      PC: aword;
    begin
      data:=objsec.data;
      for i:=0 to objsec.ObjRelocations.Count-1 do
        begin
          objreloc:=TObjRelocation(objsec.ObjRelocations[i]);
          case objreloc.typ of
            RELOC_NONE:
              continue;
            RELOC_ZERO:
              begin
                data.Seek(objreloc.dataoffset);
                zero:=0;
                data.Write(zero,4);
                continue;
              end;
          end;

          if (objreloc.flags and rf_raw)=0 then
            reltyp:=ElfTarget.encodereloc(objreloc)
          else
            reltyp:=objreloc.ftype;

          if relocs_use_addend then
            address:=objreloc.orgsize
          else
            begin
              data.Seek(objreloc.dataoffset);
              data.Read(address,4);
            end;
          if assigned(objreloc.symbol) then
            begin
              relocsec:=objreloc.symbol.objsection;
              relocval:=objreloc.symbol.address;
            end
          else if assigned(objreloc.objsection) then
            begin
              relocsec:=objreloc.objsection;
              relocval:=objreloc.objsection.mempos
            end
          else
            internalerror(2012060702);

          { Only debug sections are allowed to have relocs pointing to unused sections }
          if assigned(relocsec) and not (relocsec.used and assigned(relocsec.exesection)) and
             not (oso_debug in objsec.secoptions) then
            begin
              writeln(objsec.fullname,' references ',relocsec.fullname);
              internalerror(2012060703);
            end;

          PC:=objsec.mempos+objreloc.dataoffset;
          { TODO: if relocsec=nil, relocations must be copied to .rel.dyn section }
          if (relocsec=nil) or (relocsec.used) then
            case reltyp of
              R_386_PC32:
                begin
                  if (objreloc.flags and rf_dynamic)<>0 then
                    WriteDynRelocEntry(PC,R_386_PC32,objreloc.symbol.exesymbol.dynindex,0)
                  else
                    address:=address+relocval-PC;
                end;

              R_386_PLT32:
                begin
                  { If target is in current object, treat as RELOC_RELATIVE }
                  address:=address+relocval-PC;
                end;

              R_386_32:
                begin
                  if (objreloc.flags and rf_dynamic)<>0 then
                    begin
                      if (objreloc.symbol=nil) or
                         (objreloc.symbol.exesymbol=nil) or
                         (objreloc.symbol.exesymbol.dynindex=0) then
                        begin
                          address:=address+relocval;
                          WriteDynRelocEntry(PC,R_386_RELATIVE,0,address);
                        end
                      else
                        { Don't modify address in this case, as it serves as addend for RTLD }
                        WriteDynRelocEntry(PC,R_386_32,objreloc.symbol.exesymbol.dynindex,0);
                    end
                  else
                    address:=address+relocval;
                end;

              R_386_GOTPC:
                begin
                  address:=address+gotsymbol.address-PC;
                end;

              R_386_GOT32:
                begin
                  MaybeWriteGOTEntry(reltyp,relocval,objreloc.symbol);

                  relocval:=gotobjsec.mempos+objreloc.symbol.exesymbol.gotoffset-sizeof(pint)-gotsymbol.address;
                  address:=address+relocval;
                end;

              R_386_GOTOFF:
                begin
                  address:=address+relocval-gotsymbol.address;
                end;


              R_386_TLS_IE:
                begin
                  relocval:=-(tlsseg.MemPos+tlsseg.MemSize-relocval);
                  MaybeWriteGOTEntry(reltyp,relocval,objreloc.symbol);

                  { Resolves to *absolute* offset of GOT slot }
                  relocval:=gotobjsec.mempos+objreloc.symbol.exesymbol.gotoffset-sizeof(pint);
                  address:=address+relocval;
                end;

              R_386_TLS_LE_32,
              R_386_TLS_LE:
                begin
                  if IsSharedLibrary then
                    begin
                      {
                      if reltyp=R_386_TLS_LE_32 then
                        begin
                          WriteDynRelocEntry(PC,R_386_TLS_TPOFF32,symbol.exesymbol.dynindex,0);
                          address:=tlsseg.MemPos-relocval;
                        end;
                      else
                        begin
                          WriteDynRelocEntry(PC,R_386_TLS_TPOFF,symbol.exesymbol.dynindex,0);
                          address:=address-tlsseg.MemPos;
                        end;
                       }
                    end
                  else if (reltyp=R_386_TLS_LE) then
                    address:=-(tlsseg.MemPos+tlsseg.MemSize-relocval)
                  else
                    address:=tlsseg.MemPos+tlsseg.MemSize-relocval;
                end;

              else
                begin
                  writeln(reltyp);
                  internalerror(200604014);
                end;
            end
          else           { not relocsec.Used }
            address:=0;  { Relocation in debug section points to unused section, which is eliminated by linker }

          data.Seek(objreloc.dataoffset);
          data.Write(address,4);
        end;
    end;


{*****************************************************************************
                                    Initialize
*****************************************************************************}

  const
    as_i386_elf32_info : tasminfo =
       (
         id     : as_i386_elf32;
         idtxt  : 'ELF';
         asmbin : '';
         asmcmd : '';
         supported_targets : [system_i386_linux,system_i386_beos,
                              system_i386_freebsd,system_i386_haiku,
                              system_i386_openbsd,system_i386_netbsd,
                              system_i386_Netware,system_i386_netwlibc,
                              system_i386_solaris,system_i386_embedded];
         flags : [af_outputbinary,af_smartlink_sections,af_supports_dwarf];
         labelprefix : '.L';
         comment : '';
         dollarsign: '$';
       );

initialization
  RegisterAssembler(as_i386_elf32_info,TElfAssembler);
  ElfExeOutputClass:=TElfExeOutput386;
  ElfTarget:=TElfTarget386;

end.