mirror of
https://gitlab.com/freepascal.org/fpc/source.git
synced 2025-04-15 13:59:29 +02:00
1763 lines
60 KiB
ObjectPascal
1763 lines
60 KiB
ObjectPascal
{
|
|
$Id$
|
|
Copyright (c) 1998-2002 by Peter Vreman and Pierre Muller
|
|
|
|
Contains the binary coff reader and writer
|
|
|
|
* This code was inspired by the NASM sources
|
|
The Netwide Assembler is copyright (C) 1996 Simon Tatham and
|
|
Julian Hall. All rights reserved.
|
|
|
|
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 ogcoff;
|
|
|
|
{$i fpcdefs.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
{ common }
|
|
cclasses,
|
|
{ target }
|
|
systems,
|
|
{ assembler }
|
|
cpubase,aasmbase,assemble,link,
|
|
{ output }
|
|
ogbase,ogmap;
|
|
|
|
type
|
|
TCoffObjectSection = class(TAsmSection)
|
|
private
|
|
orgmempos,
|
|
coffrelocs,
|
|
coffrelocpos : longint;
|
|
public
|
|
constructor createsec(sec:TSection;AAlign,AFlags:cardinal);
|
|
procedure addsymsizereloc(ofs:longint;p:tasmsymbol;size:longint;relative:TAsmRelocationType);
|
|
end;
|
|
|
|
tcoffobjectdata = class(TAsmObjectData)
|
|
private
|
|
win32 : boolean;
|
|
procedure reset;
|
|
public
|
|
constructor createdjgpp(const n:string);
|
|
constructor createwin32(const n:string);
|
|
destructor destroy;override;
|
|
procedure seTSectionsizes(var s:TAsmSectionSizes);override;
|
|
procedure createsection(sec:TSection);override;
|
|
procedure writereloc(data,len:longint;p:tasmsymbol;relative:TAsmRelocationType);override;
|
|
procedure writesymbol(p:tasmsymbol);override;
|
|
procedure writestabs(section:TSection;offset:longint;p:pchar;nidx,nother,line:longint;reloc:boolean);override;
|
|
procedure writesymstabs(section:TSection;offset:longint;p:pchar;ps:tasmsymbol;nidx,nother,line:longint;reloc:boolean);override;
|
|
procedure fixuprelocs;override;
|
|
end;
|
|
|
|
tcoffobjectoutput = class(tobjectoutput)
|
|
private
|
|
win32 : boolean;
|
|
initsym : longint;
|
|
FCoffStrs : tdynamicarray;
|
|
procedure write_symbol(const name:string;strpos,value,section,typ,aux:longint);
|
|
procedure write_symbols(data:TAsmObjectData);
|
|
procedure write_relocs(data:TAsmObjectData);
|
|
protected
|
|
function writedata(data:TAsmObjectData):boolean;override;
|
|
public
|
|
constructor createdjgpp(smart:boolean);
|
|
constructor createwin32(smart:boolean);
|
|
function newobjectdata(const n:string):TAsmObjectData;override;
|
|
end;
|
|
|
|
tcoffexeoutput = class(texeoutput)
|
|
private
|
|
FCoffsyms,
|
|
FCoffStrs : tdynamicarray;
|
|
win32 : boolean;
|
|
nsects,
|
|
nsyms,
|
|
sympos : longint;
|
|
procedure write_symbol(const name:string;strpos,value,section,typ,aux:longint);
|
|
procedure write_symbols;
|
|
protected
|
|
function writedata:boolean;override;
|
|
public
|
|
constructor createdjgpp;
|
|
constructor createwin32;
|
|
function newobjectinput:tobjectinput;override;
|
|
procedure CalculateMemoryMap;override;
|
|
procedure GenerateExecutable(const fn:string);override;
|
|
end;
|
|
|
|
ttasmsymbolrec = record
|
|
sym : tasmsymbol;
|
|
orgsize : longint;
|
|
end;
|
|
ttasmsymbolarray = array[0..high(word)] of ttasmsymbolrec;
|
|
|
|
tcoffobjectinput = class(tobjectinput)
|
|
private
|
|
Fidx2sec : array[0..255] of TSection;
|
|
FCoffsyms,
|
|
FCoffStrs : tdynamicarray;
|
|
FSymTbl : ^ttasmsymbolarray;
|
|
win32 : boolean;
|
|
procedure read_relocs(s:TCoffObjectSection);
|
|
procedure handle_symbols(data:TAsmObjectData);
|
|
protected
|
|
function readobjectdata(data:TAsmObjectData):boolean;override;
|
|
public
|
|
constructor createdjgpp;
|
|
constructor createwin32;
|
|
function newobjectdata(const n:string):TAsmObjectData;override;
|
|
end;
|
|
|
|
tcoffassembler = class(tinternalassembler)
|
|
constructor create(smart:boolean);override;
|
|
end;
|
|
|
|
tpecoffassembler = class(tinternalassembler)
|
|
constructor create(smart:boolean);override;
|
|
end;
|
|
|
|
tcofflinker = class(tinternallinker)
|
|
constructor create;override;
|
|
end;
|
|
|
|
|
|
implementation
|
|
|
|
uses
|
|
{$ifdef delphi}
|
|
sysutils,
|
|
{$else}
|
|
strings,
|
|
{$endif}
|
|
cutils,verbose,
|
|
globtype,globals,fmodule;
|
|
|
|
const
|
|
COFF_FLAG_NORELOCS = $0001;
|
|
COFF_FLAG_EXE = $0002;
|
|
COFF_FLAG_NOLINES = $0004;
|
|
COFF_FLAG_NOLSYMS = $0008;
|
|
COFF_FLAG_AR16WR = $0080; { 16bit little endian }
|
|
COFF_FLAG_AR32WR = $0100; { 32bit little endian }
|
|
COFF_FLAG_AR32W = $0200; { 32bit big endian }
|
|
COFF_FLAG_DLL = $2000;
|
|
|
|
COFF_SYM_GLOBAL = 2;
|
|
COFF_SYM_LOCAL = 3;
|
|
COFF_SYM_LABEL = 6;
|
|
COFF_SYM_FUNCTION = 101;
|
|
COFF_SYM_FILE = 103;
|
|
COFF_SYM_SECTION = 104;
|
|
|
|
type
|
|
{ Structures which are written directly to the output file }
|
|
coffheader=packed record
|
|
mach : word;
|
|
nsects : word;
|
|
time : longint;
|
|
sympos : longint;
|
|
syms : longint;
|
|
opthdr : word;
|
|
flag : word;
|
|
end;
|
|
coffoptheader=packed record
|
|
magic : word;
|
|
vstamp : word;
|
|
tsize : longint;
|
|
dsize : longint;
|
|
bsize : longint;
|
|
entry : longint;
|
|
text_start : longint;
|
|
data_start : longint;
|
|
end;
|
|
coffsechdr=packed record
|
|
name : array[0..7] of char;
|
|
vsize : longint;
|
|
rvaofs : longint;
|
|
datasize : longint;
|
|
datapos : longint;
|
|
relocpos : longint;
|
|
lineno1 : longint;
|
|
nrelocs : word;
|
|
lineno2 : word;
|
|
flags : cardinal;
|
|
end;
|
|
coffsectionrec=packed record
|
|
len : longint;
|
|
nrelocs : word;
|
|
empty : array[0..11] of char;
|
|
end;
|
|
coffreloc=packed record
|
|
address : longint;
|
|
sym : longint;
|
|
relative : word;
|
|
end;
|
|
coffsymbol=packed record
|
|
name : array[0..3] of char; { real is [0..7], which overlaps the strpos ! }
|
|
strpos : longint;
|
|
value : longint;
|
|
section : smallint;
|
|
empty : smallint;
|
|
typ : byte;
|
|
aux : byte;
|
|
end;
|
|
coffstab=packed record
|
|
strpos : longint;
|
|
ntype : byte;
|
|
nother : byte;
|
|
ndesc : word;
|
|
nvalue : longint;
|
|
end;
|
|
|
|
const
|
|
symbolresize = 200*sizeof(coffsymbol);
|
|
strsresize = 8192;
|
|
|
|
|
|
const go32v2stub : array[0..2047] of byte=(
|
|
$4D,$5A,$00,$00,$04,$00,$00,$00,$20,$00,$27,$00,$FF,$FF,$00,
|
|
$00,$60,$07,$00,$00,$54,$00,$00,$00,$00,$00,$00,$00,$0D,$0A,
|
|
$73,$74,$75,$62,$2E,$68,$20,$67,$65,$6E,$65,$72,$61,$74,$65,
|
|
$64,$20,$66,$72,$6F,$6D,$20,$73,$74,$75,$62,$2E,$61,$73,$6D,
|
|
$20,$62,$79,$20,$64,$6A,$61,$73,$6D,$2C,$20,$6F,$6E,$20,$54,
|
|
$68,$75,$20,$44,$65,$63,$20,$20,$39,$20,$31,$30,$3A,$35,$39,
|
|
$3A,$33,$31,$20,$31,$39,$39,$39,$0D,$0A,$54,$68,$65,$20,$53,
|
|
$54,$55,$42,$2E,$45,$58,$45,$20,$73,$74,$75,$62,$20,$6C,$6F,
|
|
$61,$64,$65,$72,$20,$69,$73,$20,$43,$6F,$70,$79,$72,$69,$67,
|
|
$68,$74,$20,$28,$43,$29,$20,$31,$39,$39,$33,$2D,$31,$39,$39,
|
|
$35,$20,$44,$4A,$20,$44,$65,$6C,$6F,$72,$69,$65,$2E,$20,$0D,
|
|
$0A,$50,$65,$72,$6D,$69,$73,$73,$69,$6F,$6E,$20,$67,$72,$61,
|
|
$6E,$74,$65,$64,$20,$74,$6F,$20,$75,$73,$65,$20,$66,$6F,$72,
|
|
$20,$61,$6E,$79,$20,$70,$75,$72,$70,$6F,$73,$65,$20,$70,$72,
|
|
$6F,$76,$69,$64,$65,$64,$20,$74,$68,$69,$73,$20,$63,$6F,$70,
|
|
$79,$72,$69,$67,$68,$74,$20,$0D,$0A,$72,$65,$6D,$61,$69,$6E,
|
|
$73,$20,$70,$72,$65,$73,$65,$6E,$74,$20,$61,$6E,$64,$20,$75,
|
|
$6E,$6D,$6F,$64,$69,$66,$69,$65,$64,$2E,$20,$0D,$0A,$54,$68,
|
|
$69,$73,$20,$6F,$6E,$6C,$79,$20,$61,$70,$70,$6C,$69,$65,$73,
|
|
$20,$74,$6F,$20,$74,$68,$65,$20,$73,$74,$75,$62,$2C,$20,$61,
|
|
$6E,$64,$20,$6E,$6F,$74,$20,$6E,$65,$63,$65,$73,$73,$61,$72,
|
|
$69,$6C,$79,$20,$74,$68,$65,$20,$77,$68,$6F,$6C,$65,$20,$70,
|
|
$72,$6F,$67,$72,$61,$6D,$2E,$0A,$0D,$0A,$24,$49,$64,$3A,$20,
|
|
$73,$74,$75,$62,$2E,$61,$73,$6D,$20,$62,$75,$69,$6C,$74,$20,
|
|
$31,$32,$2F,$30,$39,$2F,$39,$39,$20,$31,$30,$3A,$35,$39,$3A,
|
|
$33,$31,$20,$62,$79,$20,$64,$6A,$61,$73,$6D,$20,$24,$0A,$0D,
|
|
$0A,$40,$28,$23,$29,$20,$73,$74,$75,$62,$2E,$61,$73,$6D,$20,
|
|
$62,$75,$69,$6C,$74,$20,$31,$32,$2F,$30,$39,$2F,$39,$39,$20,
|
|
$31,$30,$3A,$35,$39,$3A,$33,$31,$20,$62,$79,$20,$64,$6A,$61,
|
|
$73,$6D,$0A,$0D,$0A,$1A,$00,$00,$00,$00,$00,$00,$00,$00,$00,
|
|
$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,
|
|
$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,
|
|
$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,
|
|
$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,
|
|
$00,$00,$67,$6F,$33,$32,$73,$74,$75,$62,$2C,$20,$76,$20,$32,
|
|
$2E,$30,$32,$54,$00,$00,$00,$00,$00,$08,$00,$00,$00,$00,$00,
|
|
$00,$00,$00,$00,$00,$40,$00,$00,$00,$00,$00,$00,$00,$00,$00,
|
|
$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,
|
|
$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$43,$57,$53,$44,$50,
|
|
$4D,$49,$2E,$45,$58,$45,$00,$00,$00,$00,$00,$0E,$1F,$8C,$1E,
|
|
$24,$00,$8C,$06,$60,$07,$FC,$B4,$30,$CD,$21,$3C,$03,$73,$08,
|
|
$B0,$6D,$BA,$A7,$05,$E9,$D4,$03,$A2,$69,$08,$BE,$20,$00,$8B,
|
|
$04,$09,$C0,$75,$02,$B4,$FE,$BB,$70,$08,$39,$C3,$73,$02,$89,
|
|
$C3,$89,$1C,$FE,$C7,$B9,$04,$FF,$D3,$EB,$B4,$4A,$CD,$21,$73,
|
|
$08,$D3,$E3,$FE,$CF,$89,$1C,$EB,$D8,$26,$8E,$06,$2C,$00,$31,
|
|
$FF,$30,$C0,$A9,$F2,$AE,$26,$81,$3D,$50,$41,$75,$15,$AF,$26,
|
|
$81,$3D,$54,$48,$75,$0D,$AF,$26,$80,$3D,$3D,$75,$06,$47,$89,
|
|
$3E,$8C,$04,$4F,$AE,$75,$DF,$AF,$B4,$3E,$BB,$13,$00,$CD,$21,
|
|
$B4,$3E,$BB,$12,$00,$CD,$21,$06,$57,$31,$C9,$74,$12,$B0,$6E,
|
|
$BA,$7E,$05,$E9,$5E,$03,$09,$C9,$75,$F4,$41,$E8,$A1,$03,$72,
|
|
$EE,$B8,$87,$16,$CD,$2F,$09,$C0,$75,$ED,$80,$E3,$01,$74,$E8,
|
|
$89,$3E,$00,$06,$8C,$06,$02,$06,$89,$36,$04,$06,$5F,$07,$E8,
|
|
$D3,$02,$89,$3E,$2A,$00,$89,$36,$62,$07,$80,$3E,$2C,$00,$00,
|
|
$74,$23,$B9,$08,$00,$BF,$2C,$00,$8A,$05,$47,$08,$C0,$74,$05,
|
|
$88,$07,$43,$E2,$F4,$66,$C7,$07,$2E,$45,$58,$45,$83,$C3,$04,
|
|
$C6,$07,$00,$89,$1E,$62,$07,$B8,$00,$3D,$BA,$64,$07,$CD,$21,
|
|
$0F,$82,$B3,$02,$A3,$06,$06,$89,$C3,$B9,$06,$00,$BA,$B5,$07,
|
|
$B4,$3F,$CD,$21,$31,$D2,$31,$C9,$A1,$B5,$07,$3D,$4C,$01,$74,
|
|
$1B,$3D,$4D,$5A,$0F,$85,$98,$02,$8B,$16,$B9,$07,$C1,$E2,$09,
|
|
$8B,$1E,$B7,$07,$09,$DB,$74,$05,$80,$EE,$02,$01,$DA,$89,$16,
|
|
$BB,$07,$89,$0E,$BD,$07,$B8,$00,$42,$8B,$1E,$06,$06,$CD,$21,
|
|
$B9,$A8,$00,$BA,$BF,$07,$B4,$3F,$CD,$21,$3D,$A8,$00,$75,$06,
|
|
$81,$3E,$BF,$07,$4C,$01,$0F,$85,$61,$02,$66,$A1,$E3,$07,$66,
|
|
$A3,$10,$06,$66,$8B,$0E,$BB,$07,$66,$A1,$03,$08,$66,$01,$C8,
|
|
$66,$A3,$08,$06,$66,$A1,$2B,$08,$66,$01,$C8,$66,$A3,$0C,$06,
|
|
$66,$8B,$1E,$4B,$08,$66,$A1,$4F,$08,$66,$01,$C3,$66,$B8,$01,
|
|
$00,$01,$00,$66,$39,$C3,$73,$03,$66,$89,$C3,$66,$81,$C3,$FF,
|
|
$FF,$00,$00,$31,$DB,$66,$89,$1E,$1C,$00,$E8,$F5,$02,$8B,$1E,
|
|
$04,$06,$09,$DB,$74,$0A,$B4,$48,$CD,$21,$0F,$82,$15,$02,$8E,
|
|
$C0,$E8,$08,$03,$B8,$01,$00,$FF,$1E,$00,$06,$0F,$82,$0F,$02,
|
|
$8C,$06,$26,$00,$8C,$0E,$28,$00,$8C,$D8,$A3,$22,$00,$8E,$C0,
|
|
$31,$C0,$B9,$01,$00,$CD,$31,$72,$07,$A3,$14,$06,$31,$C0,$CD,
|
|
$31,$0F,$82,$F3,$01,$A3,$16,$06,$66,$8B,$0E,$1C,$00,$B8,$01,
|
|
$05,$8B,$1E,$1E,$00,$CD,$31,$0F,$82,$E5,$01,$89,$1E,$1A,$06,
|
|
$89,$0E,$18,$06,$89,$36,$1A,$00,$89,$3E,$18,$00,$B8,$07,$00,
|
|
$8B,$1E,$14,$06,$8B,$0E,$1A,$06,$8B,$16,$18,$06,$CD,$31,$B8,
|
|
$09,$00,$8C,$C9,$83,$E1,$03,$C1,$E1,$05,$51,$81,$C9,$9B,$C0,
|
|
$CD,$31,$B8,$08,$00,$8B,$0E,$1E,$00,$49,$BA,$FF,$FF,$CD,$31,
|
|
$B8,$07,$00,$8B,$1E,$16,$06,$8B,$0E,$1A,$06,$8B,$16,$18,$06,
|
|
$CD,$31,$B8,$09,$00,$59,$81,$C9,$93,$C0,$CD,$31,$B8,$08,$00,
|
|
$8B,$0E,$1E,$00,$49,$BA,$FF,$FF,$CD,$31,$B8,$00,$01,$BB,$00,
|
|
$0F,$CD,$31,$73,$10,$3D,$08,$00,$0F,$85,$73,$01,$B8,$00,$01,
|
|
$CD,$31,$0F,$82,$6A,$01,$A3,$1C,$06,$89,$16,$1E,$06,$C1,$E3,
|
|
$04,$89,$1E,$20,$06,$66,$8B,$36,$08,$06,$66,$8B,$3E,$FB,$07,
|
|
$66,$8B,$0E,$FF,$07,$E8,$49,$00,$66,$8B,$36,$0C,$06,$66,$8B,
|
|
$3E,$23,$08,$66,$8B,$0E,$27,$08,$E8,$37,$00,$8E,$06,$16,$06,
|
|
$66,$8B,$3E,$4B,$08,$66,$8B,$0E,$4F,$08,$66,$31,$C0,$66,$C1,
|
|
$E9,$02,$67,$F3,$66,$AB,$B4,$3E,$8B,$1E,$06,$06,$CD,$21,$B8,
|
|
$01,$01,$8B,$16,$1E,$06,$CD,$31,$1E,$0F,$A1,$8E,$1E,$16,$06,
|
|
$66,$64,$FF,$2E,$10,$06,$66,$89,$F0,$66,$25,$FF,$01,$00,$00,
|
|
$66,$01,$C1,$29,$C6,$66,$29,$C7,$66,$89,$0E,$26,$06,$66,$89,
|
|
$3E,$22,$06,$E8,$0F,$01,$89,$36,$3E,$06,$66,$C1,$EE,$10,$89,
|
|
$36,$42,$06,$8B,$1E,$06,$06,$89,$1E,$3A,$06,$C7,$06,$46,$06,
|
|
$00,$42,$E8,$03,$01,$A1,$1C,$06,$A3,$4E,$06,$C7,$06,$3E,$06,
|
|
$00,$00,$C6,$06,$47,$06,$3F,$A1,$28,$06,$09,$C0,$75,$09,$A1,
|
|
$26,$06,$3B,$06,$20,$06,$76,$03,$A1,$20,$06,$A3,$42,$06,$E8,
|
|
$D9,$00,$66,$31,$C9,$8B,$0E,$46,$06,$66,$8B,$3E,$22,$06,$66,
|
|
$01,$0E,$22,$06,$66,$29,$0E,$26,$06,$66,$31,$F6,$C1,$E9,$02,
|
|
$1E,$06,$8E,$06,$16,$06,$8E,$1E,$1E,$06,$67,$F3,$66,$A5,$07,
|
|
$1F,$66,$03,$0E,$26,$06,$75,$AF,$C3,$3C,$3A,$74,$06,$3C,$2F,
|
|
$74,$02,$3C,$5C,$C3,$BE,$64,$07,$89,$F3,$26,$8A,$05,$47,$88,
|
|
$04,$38,$E0,$74,$0E,$08,$C0,$74,$0A,$46,$E8,$DE,$FF,$75,$EC,
|
|
$89,$F3,$74,$E8,$C3,$B0,$66,$BA,$48,$05,$EB,$0C,$B0,$67,$BA,
|
|
$55,$05,$EB,$05,$B0,$68,$BA,$5F,$05,$52,$8B,$1E,$62,$07,$C6,
|
|
$07,$24,$BB,$64,$07,$EB,$28,$E8,$F5,$00,$B0,$69,$BA,$99,$05,
|
|
$EB,$1A,$B0,$6A,$BA,$B2,$05,$EB,$13,$B0,$6B,$BA,$C4,$05,$EB,
|
|
$0C,$B0,$6C,$BA,$D6,$05,$EB,$05,$B0,$69,$BA,$99,$05,$52,$BB,
|
|
$3B,$05,$E8,$15,$00,$5B,$E8,$11,$00,$BB,$67,$04,$E8,$0B,$00,
|
|
$B4,$4C,$CD,$21,$43,$50,$B4,$02,$CD,$21,$58,$8A,$17,$80,$FA,
|
|
$24,$75,$F2,$C3,$0D,$0A,$24,$50,$51,$57,$31,$C0,$BF,$2A,$06,
|
|
$B9,$19,$00,$F3,$AB,$5F,$59,$58,$C3,$B8,$00,$03,$BB,$21,$00,
|
|
$31,$C9,$66,$BF,$2A,$06,$00,$00,$CD,$31,$C3,$00,$00,$30,$E4,
|
|
$E8,$4E,$FF,$89,$DE,$8B,$3E,$8C,$04,$EB,$17,$B4,$3B,$E8,$41,
|
|
$FF,$81,$FE,$64,$07,$74,$12,$8A,$44,$FF,$E8,$2A,$FF,$74,$04,
|
|
$C6,$04,$5C,$46,$E8,$03,$00,$72,$E4,$C3,$E8,$34,$00,$BB,$44,
|
|
$00,$8A,$07,$88,$04,$43,$46,$08,$C0,$75,$F6,$06,$57,$1E,$07,
|
|
$E8,$9B,$FF,$BB,$2A,$06,$8C,$5F,$04,$89,$5F,$02,$BA,$64,$07,
|
|
$B8,$00,$4B,$CD,$21,$5F,$07,$72,$09,$B4,$4D,$CD,$21,$2D,$00,
|
|
$03,$F7,$D8,$EB,$28,$80,$3E,$69,$08,$05,$72,$20,$B8,$00,$58,
|
|
$CD,$21,$A2,$67,$08,$B8,$02,$58,$CD,$21,$A2,$68,$08,$B8,$01,
|
|
$58,$BB,$80,$00,$CD,$21,$B8,$03,$58,$BB,$01,$00,$CD,$21,$C3,
|
|
$9C,$80,$3E,$69,$08,$05,$72,$1A,$50,$53,$B8,$03,$58,$8A,$1E,
|
|
$68,$08,$30,$FF,$CD,$21,$B8,$01,$58,$8A,$1E,$67,$08,$30,$FF,
|
|
$CD,$21,$5B,$58,$9D,$C3,$4C,$6F,$61,$64,$20,$65,$72,$72,$6F,
|
|
$72,$3A,$20,$24,$3A,$20,$63,$61,$6E,$27,$74,$20,$6F,$70,$65,
|
|
$6E,$24,$3A,$20,$6E,$6F,$74,$20,$45,$58,$45,$24,$3A,$20,$6E,
|
|
$6F,$74,$20,$43,$4F,$46,$46,$20,$28,$43,$68,$65,$63,$6B,$20,
|
|
$66,$6F,$72,$20,$76,$69,$72,$75,$73,$65,$73,$29,$24,$6E,$6F,
|
|
$20,$44,$50,$4D,$49,$20,$2D,$20,$47,$65,$74,$20,$63,$73,$64,
|
|
$70,$6D,$69,$2A,$62,$2E,$7A,$69,$70,$24,$6E,$6F,$20,$44,$4F,
|
|
$53,$20,$6D,$65,$6D,$6F,$72,$79,$24,$6E,$65,$65,$64,$20,$44,
|
|
$4F,$53,$20,$33,$24,$63,$61,$6E,$27,$74,$20,$73,$77,$69,$74,
|
|
$63,$68,$20,$6D,$6F,$64,$65,$24,$6E,$6F,$20,$44,$50,$4D,$49,
|
|
$20,$73,$65,$6C,$65,$63,$74,$6F,$72,$73,$24,$6E,$6F,$20,$44,
|
|
$50,$4D,$49,$20,$6D,$65,$6D,$6F,$72,$79,$24,$90,$90,$90,$90,
|
|
$90,$90,$90,$90,$90,$90,$90,$90,$90,$90,$90,$90,$90,$90,$90,
|
|
$90,$90,$90,$90,$90,$90,$90,$90);
|
|
|
|
|
|
{****************************************************************************
|
|
TCoffObjectSection
|
|
****************************************************************************}
|
|
|
|
constructor TCoffObjectSection.createsec(sec:TSection;AAlign,AFlags:cardinal);
|
|
begin
|
|
inherited create(target_asm.secnames[sec],AAlign,(sec=sec_bss));
|
|
Flags:=AFlags;
|
|
end;
|
|
|
|
|
|
procedure TCoffObjectSection.addsymsizereloc(ofs:longint;p:tasmsymbol;size:longint;relative:TAsmRelocationType);
|
|
begin
|
|
relocations.concat(tasmrelocation.createsymbolsize(ofs,p,size,relative));
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
tcoffobjectdata
|
|
****************************************************************************}
|
|
|
|
constructor tcoffobjectdata.createdjgpp(const n:string);
|
|
begin
|
|
inherited create(n);
|
|
win32:=false;
|
|
reset;
|
|
end;
|
|
|
|
|
|
constructor tcoffobjectdata.createwin32(const n:string);
|
|
begin
|
|
inherited create(n);
|
|
win32:=true;
|
|
reset;
|
|
end;
|
|
|
|
|
|
destructor tcoffobjectdata.destroy;
|
|
begin
|
|
inherited destroy;
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectdata.reset;
|
|
var
|
|
s : string;
|
|
begin
|
|
{ we need at least the following 3 sections }
|
|
createsection(sec_code);
|
|
createsection(sec_data);
|
|
createsection(sec_bss);
|
|
if (cs_gdb_lineinfo in aktglobalswitches) or
|
|
(cs_debuginfo in aktmoduleswitches) then
|
|
begin
|
|
createsection(sec_stab);
|
|
createsection(sec_stabstr);
|
|
writestabs(sec_none,0,nil,0,0,0,false);
|
|
{ write zero pchar and name together (PM) }
|
|
s:=#0+SplitFileName(current_module.mainsource^)+#0;
|
|
sects[sec_stabstr].write(s[1],length(s));
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectdata.createsection(sec:TSection);
|
|
var
|
|
Flags,
|
|
AAlign : cardinal;
|
|
begin
|
|
{ defaults }
|
|
Flags:=0;
|
|
Aalign:=1;
|
|
{ alignment after section }
|
|
case sec of
|
|
sec_code :
|
|
begin
|
|
if win32 then
|
|
Flags:=$60000020
|
|
else
|
|
Flags:=$20;
|
|
Aalign:=16;
|
|
end;
|
|
sec_data :
|
|
begin
|
|
if win32 then
|
|
Flags:=$c0300040
|
|
else
|
|
Flags:=$40;
|
|
Aalign:=16;
|
|
end;
|
|
sec_bss :
|
|
begin
|
|
if win32 then
|
|
Flags:=$c0300080
|
|
else
|
|
Flags:=$80;
|
|
Aalign:=16;
|
|
end;
|
|
sec_idata2,
|
|
sec_idata4,
|
|
sec_idata5,
|
|
sec_idata6,
|
|
sec_idata7 :
|
|
begin
|
|
if win32 then
|
|
Flags:=$40000000;
|
|
end;
|
|
sec_edata :
|
|
begin
|
|
if win32 then
|
|
Flags:=$c0300040;
|
|
end;
|
|
end;
|
|
sects[sec]:=TCoffObjectSection.createsec(Sec,AAlign,Flags);
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectdata.writesymbol(p:tasmsymbol);
|
|
begin
|
|
{ already written ? }
|
|
if p.indexnr<>-1 then
|
|
exit;
|
|
{ be sure that the section will exists }
|
|
if (p.section<>sec_none) and not(assigned(sects[p.section])) then
|
|
createsection(p.section);
|
|
{ calculate symbol index }
|
|
if (p.currbind<>AB_LOCAL) then
|
|
begin
|
|
{ insert the symbol in the local index, the indexarray
|
|
will take care of the numbering }
|
|
symbols.insert(p);
|
|
end
|
|
else
|
|
p.indexnr:=-2; { local }
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectdata.writereloc(data,len:longint;p:tasmsymbol;relative:TAsmRelocationType);
|
|
var
|
|
curraddr,
|
|
symaddr : longint;
|
|
begin
|
|
if not assigned(sects[currsec]) then
|
|
createsection(currsec);
|
|
if assigned(p) then
|
|
begin
|
|
{ current address }
|
|
curraddr:=sects[currsec].mempos+sects[currsec].datasize;
|
|
{ real address of the symbol }
|
|
symaddr:=p.address;
|
|
if p.section<>sec_none then
|
|
inc(symaddr,sects[p.section].mempos);
|
|
{ no symbol relocation need inside a section }
|
|
if p.section=currsec then
|
|
begin
|
|
case relative of
|
|
RELOC_ABSOLUTE :
|
|
begin
|
|
sects[currsec].addsectionreloc(curraddr,currsec,RELOC_ABSOLUTE);
|
|
inc(data,symaddr);
|
|
end;
|
|
RELOC_RELATIVE :
|
|
begin
|
|
inc(data,symaddr-len-sects[currsec].datasize);
|
|
end;
|
|
RELOC_RVA :
|
|
begin
|
|
sects[currsec].addsectionreloc(curraddr,currsec,RELOC_RVA);
|
|
inc(data,symaddr);
|
|
end;
|
|
end;
|
|
end
|
|
else
|
|
begin
|
|
writesymbol(p);
|
|
if (p.section<>sec_none) and (relative<>RELOC_RELATIVE) then
|
|
sects[currsec].addsectionreloc(curraddr,p.section,relative)
|
|
else
|
|
sects[currsec].addsymreloc(curraddr,p,relative);
|
|
if not win32 then {seems wrong to me (PM) }
|
|
inc(data,symaddr)
|
|
else
|
|
if (relative<>RELOC_RELATIVE) and (p.section<>sec_none) then
|
|
inc(data,symaddr);
|
|
if relative=RELOC_RELATIVE then
|
|
begin
|
|
if win32 then
|
|
dec(data,len-4)
|
|
else
|
|
dec(data,len+sects[currsec].datasize);
|
|
end;
|
|
end;
|
|
end;
|
|
sects[currsec].write(data,len);
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectdata.writestabs(section:TSection;offset:longint;p:pchar;nidx,nother,line:longint;reloc : boolean);
|
|
var
|
|
stab : coffstab;
|
|
s : TSection;
|
|
curraddr : longint;
|
|
begin
|
|
s:=section;
|
|
{ local var can be at offset -1 !! PM }
|
|
if reloc then
|
|
begin
|
|
if (offset=-1) then
|
|
begin
|
|
if s=sec_none then
|
|
offset:=0
|
|
else
|
|
offset:=sects[s].datasize;
|
|
end;
|
|
if (s<>sec_none) then
|
|
inc(offset,sects[s].datapos);
|
|
end;
|
|
if assigned(p) and (p[0]<>#0) then
|
|
begin
|
|
stab.strpos:=sects[sec_stabstr].datasize;
|
|
sects[sec_stabstr].write(p^,strlen(p)+1);
|
|
end
|
|
else
|
|
stab.strpos:=0;
|
|
stab.ntype:=nidx;
|
|
stab.ndesc:=line;
|
|
stab.nother:=nother;
|
|
stab.nvalue:=offset;
|
|
sects[sec_stab].write(stab,sizeof(stab));
|
|
{ when the offset is not 0 then write a relocation, take also the
|
|
hdrstab into account with the offset }
|
|
if reloc then
|
|
begin
|
|
{ current address }
|
|
curraddr:=sects[sec_stab].mempos+sects[sec_stab].datasize;
|
|
if DLLSource and RelocSection then
|
|
{ avoid relocation in the .stab section
|
|
because it ends up in the .reloc section instead }
|
|
sects[sec_stab].addsectionreloc(curraddr-4,s,RELOC_RVA)
|
|
else
|
|
sects[sec_stab].addsectionreloc(curraddr-4,s,RELOC_ABSOLUTE);
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectdata.writesymstabs(section:TSection;offset:longint;p:pchar;ps:tasmsymbol;
|
|
nidx,nother,line:longint;reloc:boolean);
|
|
var
|
|
stab : coffstab;
|
|
curraddr : longint;
|
|
begin
|
|
{ do not use the size stored in offset field
|
|
this is DJGPP specific ! PM }
|
|
if win32 then
|
|
offset:=0;
|
|
{ local var can be at offset -1 !! PM }
|
|
if reloc then
|
|
begin
|
|
if (offset=-1) then
|
|
begin
|
|
if section=sec_none then
|
|
offset:=0
|
|
else
|
|
offset:=sects[section].datasize;
|
|
end;
|
|
if (section<>sec_none) then
|
|
inc(offset,sects[section].mempos);
|
|
end;
|
|
if assigned(p) and (p[0]<>#0) then
|
|
begin
|
|
stab.strpos:=sects[sec_stabstr].datasize;
|
|
sects[sec_stabstr].write(p^,strlen(p)+1);
|
|
end
|
|
else
|
|
stab.strpos:=0;
|
|
stab.ntype:=nidx;
|
|
stab.ndesc:=line;
|
|
stab.nother:=nother;
|
|
stab.nvalue:=offset;
|
|
sects[sec_stab].write(stab,sizeof(stab));
|
|
{ when the offset is not 0 then write a relocation, take also the
|
|
hdrstab into account with the offset }
|
|
if reloc then
|
|
begin
|
|
{ current address }
|
|
curraddr:=sects[sec_stab].mempos+sects[sec_stab].datasize;
|
|
if DLLSource and RelocSection then
|
|
{ avoid relocation in the .stab section
|
|
because it ends up in the .reloc section instead }
|
|
sects[sec_stab].addsymreloc(curraddr-4,ps,RELOC_RVA)
|
|
else
|
|
sects[sec_stab].addsymreloc(curraddr-4,ps,RELOC_ABSOLUTE);
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectdata.seTSectionsizes(var s:TAsmSectionSizes);
|
|
var
|
|
mempos : longint;
|
|
sec : TSection;
|
|
begin
|
|
{ multiply stab with real size }
|
|
s[sec_stab]:=s[sec_stab]*sizeof(coffstab);
|
|
{ if debug then also count header stab }
|
|
if (cs_debuginfo in aktmoduleswitches) then
|
|
begin
|
|
inc(s[sec_stab],sizeof(coffstab));
|
|
inc(s[sec_stabstr],length(SplitFileName(current_module.mainsource^))+2);
|
|
end;
|
|
{ calc mempos }
|
|
mempos:=0;
|
|
for sec:=low(TSection) to high(TSection) do
|
|
begin
|
|
if (s[sec]>0) and
|
|
(not assigned(sects[sec])) then
|
|
createsection(sec);
|
|
if assigned(sects[sec]) then
|
|
begin
|
|
sects[sec].memsize:=s[sec];
|
|
{ memory position }
|
|
if not win32 then
|
|
begin
|
|
sects[sec].mempos:=mempos;
|
|
inc(mempos,align(sects[sec].memsize,sects[sec].addralign));
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectdata.fixuprelocs;
|
|
var
|
|
r : TAsmRelocation;
|
|
address,
|
|
relocval : longint;
|
|
sec : TSection;
|
|
begin
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if assigned(sects[sec]) then
|
|
begin
|
|
r:=TAsmRelocation(sects[sec].relocations.first);
|
|
if assigned(r) and
|
|
(not assigned(sects[sec].data)) then
|
|
internalerror(200205183);
|
|
while assigned(r) do
|
|
begin
|
|
if assigned(r.symbol) then
|
|
relocval:=r.symbol.address
|
|
else
|
|
internalerror(200205183);
|
|
sects[sec].data.Seek(r.address);
|
|
sects[sec].data.Read(address,4);
|
|
case r.typ of
|
|
RELOC_RELATIVE :
|
|
begin
|
|
dec(address,sects[sec].mempos);
|
|
inc(address,relocval);
|
|
end;
|
|
RELOC_RVA,
|
|
RELOC_ABSOLUTE :
|
|
begin
|
|
if r.symbol.section=sec_common then
|
|
dec(address,r.orgsize)
|
|
else
|
|
begin
|
|
{ fixup address when the symbol was known in defined object }
|
|
if (r.symbol.section<>sec_none) and
|
|
(r.symbol.objectdata=pointer(self)) then
|
|
dec(address,TCoffObjectSection(sects[r.symbol.section]).orgmempos);
|
|
end;
|
|
inc(address,relocval);
|
|
end;
|
|
end;
|
|
sects[sec].data.Seek(r.address);
|
|
sects[sec].data.Write(address,4);
|
|
{ goto next reloc }
|
|
r:=TAsmRelocation(r.next);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
tcoffobjectoutput
|
|
****************************************************************************}
|
|
|
|
constructor tcoffobjectoutput.createdjgpp(smart:boolean);
|
|
begin
|
|
inherited create(smart);
|
|
win32:=false;
|
|
end;
|
|
|
|
|
|
constructor tcoffobjectoutput.createwin32(smart:boolean);
|
|
begin
|
|
inherited create(smart);
|
|
win32:=true;
|
|
end;
|
|
|
|
|
|
function tcoffobjectoutput.newobjectdata(const n:string):TAsmObjectData;
|
|
begin
|
|
if win32 then
|
|
result:=tcoffobjectdata.createwin32(n)
|
|
else
|
|
result:=tcoffobjectdata.createdjgpp(n);
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectoutput.write_symbol(const name:string;strpos,value,section,typ,aux:longint);
|
|
var
|
|
sym : coffsymbol;
|
|
begin
|
|
FillChar(sym,sizeof(sym),0);
|
|
if strpos=-1 then
|
|
move(name[1],sym.name,length(name))
|
|
else
|
|
sym.strpos:=strpos;
|
|
sym.value:=value;
|
|
sym.section:=section;
|
|
sym.typ:=typ;
|
|
sym.aux:=aux;
|
|
FWriter.write(sym,sizeof(sym));
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectoutput.write_symbols(data:TAsmObjectData);
|
|
var
|
|
filename : string[18];
|
|
sec : TSection;
|
|
namestr : string[8];
|
|
value,
|
|
nameidx : longint;
|
|
sectionval,
|
|
globalval : byte;
|
|
secrec : coffsectionrec;
|
|
p : tasmsymbol;
|
|
s : string;
|
|
begin
|
|
with tcoffobjectdata(data) do
|
|
begin
|
|
{ The `.file' record, and the file name auxiliary record }
|
|
write_symbol('.file', -1, 0, -2, $67, 1);
|
|
fillchar(filename,sizeof(filename),0);
|
|
filename:=SplitFileName(current_module.mainsource^);
|
|
FWriter.write(filename[1],sizeof(filename)-1);
|
|
{ The section records, with their auxiliaries, also store the
|
|
symbol index }
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if assigned(sects[sec]) then
|
|
begin
|
|
write_symbol(target_asm.secnames[sec],-1,sects[sec].mempos,sects[sec].secsymidx,3,1);
|
|
fillchar(secrec,sizeof(secrec),0);
|
|
secrec.len:=sects[sec].aligneddatasize;
|
|
secrec.nrelocs:=sects[sec].relocations.count;
|
|
FWriter.write(secrec,sizeof(secrec));
|
|
end;
|
|
{ The symbols used }
|
|
p:=Tasmsymbol(symbols.First);
|
|
while assigned(p) do
|
|
begin
|
|
if assigned(sects[p.section]) then
|
|
sectionval:=sects[p.section].secsymidx
|
|
else
|
|
sectionval:=0;
|
|
if p.currbind=AB_LOCAL then
|
|
globalval:=3
|
|
else
|
|
globalval:=2;
|
|
{ if local of global then set the section value to the address
|
|
of the symbol }
|
|
if p.currbind in [AB_LOCAL,AB_GLOBAL] then
|
|
value:=p.address+sects[p.section].mempos
|
|
else
|
|
value:=p.size;
|
|
{ symbolname }
|
|
s:=p.name;
|
|
if length(s)>8 then
|
|
begin
|
|
nameidx:=FCoffStrs.size+4;
|
|
FCoffStrs.writestr(s);
|
|
FCoffStrs.writestr(#0);
|
|
end
|
|
else
|
|
begin
|
|
nameidx:=-1;
|
|
namestr:=s;
|
|
end;
|
|
write_symbol(namestr,nameidx,value,sectionval,globalval,0);
|
|
p:=tasmsymbol(p.indexnext);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectoutput.write_relocs(data:TAsmObjectData);
|
|
var
|
|
rel : coffreloc;
|
|
r : TAsmRelocation;
|
|
sec : TSection;
|
|
begin
|
|
with data do
|
|
begin
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if assigned(sects[sec]) then
|
|
begin
|
|
r:=TasmRelocation(sects[sec].relocations.first);
|
|
while assigned(r) do
|
|
begin
|
|
rel.address:=r.address;
|
|
if assigned(r.symbol) then
|
|
begin
|
|
if (r.symbol.currbind=AB_LOCAL) then
|
|
rel.sym:=2*sects[r.symbol.section].secsymidx
|
|
else
|
|
begin
|
|
if r.symbol.indexnr=-1 then
|
|
internalerror(4321);
|
|
{ indexnr starts with 1, coff starts with 0 }
|
|
rel.sym:=r.symbol.indexnr+initsym-1;
|
|
end;
|
|
end
|
|
else
|
|
begin
|
|
if r.section<>sec_none then
|
|
rel.sym:=2*sects[r.section].secsymidx
|
|
else
|
|
rel.sym:=0;
|
|
end;
|
|
case r.typ of
|
|
RELOC_RELATIVE : rel.relative:=$14;
|
|
RELOC_ABSOLUTE : rel.relative:=$6;
|
|
RELOC_RVA : rel.relative:=$7;
|
|
end;
|
|
FWriter.write(rel,sizeof(rel));
|
|
r:=TAsmRelocation(r.next);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function tcoffobjectoutput.writedata(data:TAsmObjectData):boolean;
|
|
var
|
|
datapos,
|
|
secsymidx,
|
|
nsects,
|
|
sympos,i : longint;
|
|
hstab : coffstab;
|
|
gotreloc : boolean;
|
|
sec : TSection;
|
|
header : coffheader;
|
|
sechdr : coffsechdr;
|
|
empty : array[0..15] of byte;
|
|
hp : pdynamicblock;
|
|
begin
|
|
result:=false;
|
|
FCoffStrs:=TDynamicArray.Create(strsresize);
|
|
with tcoffobjectdata(data) do
|
|
begin
|
|
{ calc amount of sections we have }
|
|
fillchar(empty,sizeof(empty),0);
|
|
nsects:=0;
|
|
initsym:=2; { 2 for the file }
|
|
secsymidx:=0;
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if assigned(sects[sec]) then
|
|
begin
|
|
inc(nsects);
|
|
inc(secsymidx);
|
|
sects[sec].secsymidx:=secsymidx;
|
|
inc(initsym,2); { 2 for each section }
|
|
end;
|
|
{ For the stab section we need an HdrSym which can now be
|
|
calculated more easily }
|
|
if assigned(sects[sec_stab]) then
|
|
begin
|
|
hstab.strpos:=1;
|
|
hstab.ntype:=0;
|
|
hstab.nother:=0;
|
|
hstab.ndesc:=(sects[sec_stab].datasize div sizeof(coffstab))-1{+1 according to gas output PM};
|
|
hstab.nvalue:=sects[sec_stabstr].datasize;
|
|
sects[sec_stab].data.seek(0);
|
|
sects[sec_stab].data.write(hstab,sizeof(hstab));
|
|
end;
|
|
{ Calculate the filepositions }
|
|
datapos:=sizeof(coffheader)+sizeof(coffsechdr)*nsects;
|
|
{ sections first }
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if assigned(sects[sec]) then
|
|
begin
|
|
sects[sec].datapos:=datapos;
|
|
if assigned(sects[sec].data) then
|
|
inc(datapos,sects[sec].aligneddatasize);
|
|
end;
|
|
{ relocs }
|
|
gotreloc:=false;
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if assigned(sects[sec]) then
|
|
begin
|
|
TCoffObjectSection(sects[sec]).coffrelocpos:=datapos;
|
|
inc(datapos,10*sects[sec].relocations.count);
|
|
if (not gotreloc) and (sects[sec].relocations.count>0) then
|
|
gotreloc:=true;
|
|
end;
|
|
{ symbols }
|
|
sympos:=datapos;
|
|
{ COFF header }
|
|
fillchar(header,sizeof(coffheader),0);
|
|
header.mach:=$14c;
|
|
header.nsects:=nsects;
|
|
header.sympos:=sympos;
|
|
header.syms:=symbols.count+initsym;
|
|
header.flag:=COFF_FLAG_AR32WR or COFF_FLAG_NOLINES;
|
|
if not gotreloc then
|
|
header.flag:=header.flag or COFF_FLAG_NORELOCS;
|
|
FWriter.write(header,sizeof(header));
|
|
{ Section headers }
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if assigned(sects[sec]) then
|
|
begin
|
|
fillchar(sechdr,sizeof(sechdr),0);
|
|
move(target_asm.secnames[sec][1],sechdr.name,length(target_asm.secnames[sec]));
|
|
if not win32 then
|
|
begin
|
|
sechdr.rvaofs:=sects[sec].mempos;
|
|
sechdr.vsize:=sects[sec].mempos;
|
|
end
|
|
else
|
|
begin
|
|
if sec=sec_bss then
|
|
sechdr.vsize:=sects[sec].aligneddatasize;
|
|
end;
|
|
sechdr.datasize:=sects[sec].aligneddatasize;
|
|
if (sects[sec].datasize>0) and assigned(sects[sec].data) then
|
|
sechdr.datapos:=sects[sec].datapos;
|
|
sechdr.nrelocs:=sects[sec].relocations.count;
|
|
sechdr.relocpos:=TCoffObjectSection(sects[sec]).coffrelocpos;
|
|
sechdr.flags:=TCoffObjectSection(sects[sec]).flags;
|
|
FWriter.write(sechdr,sizeof(sechdr));
|
|
end;
|
|
{ Sections }
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if assigned(sects[sec]) and
|
|
assigned(sects[sec].data) then
|
|
begin
|
|
sects[sec].alignsection;
|
|
hp:=sects[sec].data.firstblock;
|
|
while assigned(hp) do
|
|
begin
|
|
FWriter.write(hp^.data,hp^.used);
|
|
hp:=hp^.next;
|
|
end;
|
|
end;
|
|
{ Relocs }
|
|
write_relocs(data);
|
|
{ Symbols }
|
|
write_symbols(data);
|
|
{ Strings }
|
|
i:=FCoffStrs.size+4;
|
|
FWriter.write(i,4);
|
|
hp:=FCoffStrs.firstblock;
|
|
while assigned(hp) do
|
|
begin
|
|
FWriter.write(hp^.data,hp^.used);
|
|
hp:=hp^.next;
|
|
end;
|
|
end;
|
|
FCoffStrs.Free;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
tcoffexeoutput
|
|
****************************************************************************}
|
|
|
|
constructor tcoffexeoutput.createdjgpp;
|
|
begin
|
|
inherited create;
|
|
win32:=false;
|
|
end;
|
|
|
|
|
|
constructor tcoffexeoutput.createwin32;
|
|
begin
|
|
inherited create;
|
|
win32:=true;
|
|
end;
|
|
|
|
|
|
function tcoffexeoutput.newobjectinput:tobjectinput;
|
|
begin
|
|
if win32 then
|
|
result:=tcoffobjectinput.createwin32
|
|
else
|
|
result:=tcoffobjectinput.createdjgpp;
|
|
end;
|
|
|
|
|
|
procedure tcoffexeoutput.write_symbol(const name:string;strpos,value,section,typ,aux:longint);
|
|
var
|
|
sym : coffsymbol;
|
|
begin
|
|
FillChar(sym,sizeof(sym),0);
|
|
if strpos=-1 then
|
|
move(name[1],sym.name,length(name))
|
|
else
|
|
sym.strpos:=strpos;
|
|
sym.value:=value;
|
|
sym.section:=section;
|
|
sym.typ:=typ;
|
|
sym.aux:=aux;
|
|
FWriter.write(sym,sizeof(sym));
|
|
end;
|
|
|
|
|
|
procedure tcoffexeoutput.write_symbols;
|
|
var
|
|
namestr : string[8];
|
|
nameidx : longint;
|
|
value,
|
|
sectionval,
|
|
globalval : byte;
|
|
objdata : TAsmObjectData;
|
|
p : tasmsymbol;
|
|
s : string;
|
|
begin
|
|
objdata:=TAsmObjectData(objdatalist.first);
|
|
while assigned(objdata) do
|
|
begin
|
|
with tcoffobjectdata(objdata) do
|
|
begin
|
|
{ The symbols used }
|
|
p:=Tasmsymbol(symbols.First);
|
|
while assigned(p) do
|
|
begin
|
|
if p.section=sec_common then
|
|
sectionval:=sections[sec_bss].secsymidx
|
|
else
|
|
sectionval:=sections[p.section].secsymidx;
|
|
if p.currbind=AB_LOCAL then
|
|
globalval:=3
|
|
else
|
|
globalval:=2;
|
|
{ if local of global then set the section value to the address
|
|
of the symbol }
|
|
if p.currbind in [AB_LOCAL,AB_GLOBAL] then
|
|
value:=p.address
|
|
else
|
|
value:=p.size;
|
|
{ symbolname }
|
|
s:=p.name;
|
|
if length(s)>8 then
|
|
begin
|
|
nameidx:=FCoffStrs.size+4;
|
|
FCoffStrs.writestr(s);
|
|
FCoffStrs.writestr(#0);
|
|
end
|
|
else
|
|
begin
|
|
nameidx:=-1;
|
|
namestr:=s;
|
|
end;
|
|
write_symbol(namestr,nameidx,value,sectionval,globalval,0);
|
|
p:=tasmsymbol(p.indexnext);
|
|
end;
|
|
end;
|
|
objdata:=TAsmObjectData(objdata.next);
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tcoffexeoutput.CalculateMemoryMap;
|
|
var
|
|
objdata : TAsmObjectData;
|
|
secsymidx,
|
|
mempos,
|
|
datapos : longint;
|
|
sec : TSection;
|
|
begin
|
|
{ retrieve amount of sections }
|
|
nsects:=0;
|
|
secsymidx:=0;
|
|
for sec:=low(TSection) to high(TSection) do
|
|
begin
|
|
if sections[sec].available then
|
|
begin
|
|
inc(nsects);
|
|
inc(secsymidx);
|
|
sections[sec].secsymidx:=secsymidx;
|
|
end;
|
|
end;
|
|
{ calculate start positions after the headers }
|
|
datapos:=sizeof(coffheader)+sizeof(coffoptheader)+sizeof(coffsechdr)*nsects;
|
|
mempos:=sizeof(coffheader)+sizeof(coffoptheader)+sizeof(coffsechdr)*nsects;
|
|
if not win32 then
|
|
inc(mempos,sizeof(go32v2stub)+$1000);
|
|
{ add sections }
|
|
MapObjectdata(datapos,mempos);
|
|
{ end symbol }
|
|
AddGlobalSym('_etext',sections[sec_code].mempos+sections[sec_code].memsize);
|
|
AddGlobalSym('_edata',sections[sec_data].mempos+sections[sec_data].memsize);
|
|
AddGlobalSym('end',mempos);
|
|
{ symbols }
|
|
nsyms:=0;
|
|
sympos:=0;
|
|
if not(cs_link_strip in aktglobalswitches) then
|
|
begin
|
|
sympos:=datapos;
|
|
objdata:=TAsmObjectData(objdatalist.first);
|
|
while assigned(objdata) do
|
|
begin
|
|
inc(nsyms,objdata.symbols.count);
|
|
objdata:=TAsmObjectData(objdata.next);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function tcoffexeoutput.writedata:boolean;
|
|
var
|
|
i : longint;
|
|
sec : TSection;
|
|
header : coffheader;
|
|
optheader : coffoptheader;
|
|
sechdr : coffsechdr;
|
|
hp : pdynamicblock;
|
|
objdata : TAsmObjectData;
|
|
hsym : tasmsymbol;
|
|
begin
|
|
result:=false;
|
|
FCoffSyms:=TDynamicArray.Create(symbolresize);
|
|
FCoffStrs:=TDynamicArray.Create(strsresize);
|
|
{ Stub }
|
|
if not win32 then
|
|
FWriter.write(go32v2stub,sizeof(go32v2stub));
|
|
{ COFF header }
|
|
fillchar(header,sizeof(header),0);
|
|
header.mach:=$14c;
|
|
header.nsects:=nsects;
|
|
header.sympos:=sympos;
|
|
header.syms:=nsyms;
|
|
header.opthdr:=sizeof(coffoptheader);
|
|
header.flag:=COFF_FLAG_AR32WR or COFF_FLAG_EXE or COFF_FLAG_NORELOCS or COFF_FLAG_NOLINES;
|
|
FWriter.write(header,sizeof(header));
|
|
{ Optional COFF Header }
|
|
fillchar(optheader,sizeof(optheader),0);
|
|
optheader.magic:=$10b;
|
|
optheader.tsize:=sections[sec_code].memsize;
|
|
optheader.dsize:=sections[sec_data].memsize;
|
|
optheader.bsize:=sections[sec_bss].memsize;
|
|
hsym:=tasmsymbol(globalsyms.search('start'));
|
|
if not assigned(hsym) then
|
|
begin
|
|
Comment(V_Error,'Entrypoint "start" not defined');
|
|
exit;
|
|
end;
|
|
optheader.entry:=hsym.address;
|
|
optheader.text_start:=sections[sec_code].mempos;
|
|
optheader.data_start:=sections[sec_data].mempos;
|
|
FWriter.write(optheader,sizeof(optheader));
|
|
{ Section headers }
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if sections[sec].available then
|
|
begin
|
|
fillchar(sechdr,sizeof(sechdr),0);
|
|
move(target_asm.secnames[sec][1],sechdr.name,length(target_asm.secnames[sec]));
|
|
if not win32 then
|
|
begin
|
|
sechdr.rvaofs:=sections[sec].mempos;
|
|
sechdr.vsize:=sections[sec].mempos;
|
|
end
|
|
else
|
|
begin
|
|
if sec=sec_bss then
|
|
sechdr.vsize:=sections[sec].memsize;
|
|
end;
|
|
if sec=sec_bss then
|
|
sechdr.datasize:=sections[sec].memsize
|
|
else
|
|
begin
|
|
sechdr.datasize:=sections[sec].datasize;
|
|
sechdr.datapos:=sections[sec].datapos;
|
|
end;
|
|
sechdr.nrelocs:=0;
|
|
sechdr.relocpos:=0;
|
|
sechdr.flags:=sections[sec].flags;
|
|
FWriter.write(sechdr,sizeof(sechdr));
|
|
end;
|
|
{ Sections }
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if sections[sec].available then
|
|
begin
|
|
{ update objectfiles }
|
|
objdata:=TAsmObjectData(objdatalist.first);
|
|
while assigned(objdata) do
|
|
begin
|
|
if assigned(objdata.sects[sec]) and
|
|
assigned(objdata.sects[sec].data) then
|
|
begin
|
|
WriteZeros(objdata.sects[sec].dataalignbytes);
|
|
hp:=objdata.sects[sec].data.firstblock;
|
|
while assigned(hp) do
|
|
begin
|
|
FWriter.write(hp^.data,hp^.used);
|
|
hp:=hp^.next;
|
|
end;
|
|
end;
|
|
objdata:=TAsmObjectData(objdata.next);
|
|
end;
|
|
end;
|
|
{ Optional symbols }
|
|
if not(cs_link_strip in aktglobalswitches) then
|
|
begin
|
|
{ Symbols }
|
|
write_symbols;
|
|
{ Strings }
|
|
i:=FCoffStrs.size+4;
|
|
FWriter.write(i,4);
|
|
hp:=FCoffStrs.firstblock;
|
|
while assigned(hp) do
|
|
begin
|
|
FWriter.write(hp^.data,hp^.used);
|
|
hp:=hp^.next;
|
|
end;
|
|
end;
|
|
{ Release }
|
|
FCoffStrs.Free;
|
|
FCoffSyms.Free;
|
|
result:=true;
|
|
end;
|
|
|
|
|
|
procedure tcoffexeoutput.GenerateExecutable(const fn:string);
|
|
begin
|
|
AddGlobalSym('_etext',0);
|
|
AddGlobalSym('_edata',0);
|
|
AddGlobalSym('end',0);
|
|
if not CalculateSymbols then
|
|
exit;
|
|
CalculateMemoryMap;
|
|
FixupSymbols;
|
|
FixupRelocations;
|
|
writeexefile(fn);
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
tcoffobjectinput
|
|
****************************************************************************}
|
|
|
|
constructor tcoffobjectinput.createdjgpp;
|
|
begin
|
|
inherited create;
|
|
win32:=false;
|
|
end;
|
|
|
|
|
|
constructor tcoffobjectinput.createwin32;
|
|
begin
|
|
inherited create;
|
|
win32:=true;
|
|
end;
|
|
|
|
|
|
function tcoffobjectinput.newobjectdata(const n:string):TAsmObjectData;
|
|
begin
|
|
if win32 then
|
|
result:=tcoffobjectdata.createwin32(n)
|
|
else
|
|
result:=tcoffobjectdata.createdjgpp(n);
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectinput.read_relocs(s:TCoffObjectSection);
|
|
var
|
|
rel : coffreloc;
|
|
rel_type : TAsmRelocationType;
|
|
i : longint;
|
|
p : tasmsymbol;
|
|
begin
|
|
for i:=1 to s.coffrelocs do
|
|
begin
|
|
FReader.read(rel,sizeof(rel));
|
|
case rel.relative of
|
|
$14 : rel_type:=RELOC_RELATIVE;
|
|
$06 : rel_type:=RELOC_ABSOLUTE;
|
|
$07 : rel_type:=RELOC_RVA;
|
|
else
|
|
begin
|
|
Comment(V_Error,'Error reading coff file');
|
|
exit;
|
|
end;
|
|
end;
|
|
|
|
p:=FSymTbl^[rel.sym].sym;
|
|
if assigned(p) then
|
|
begin
|
|
s.addsymsizereloc(rel.address-s.mempos,p,FSymTbl^[rel.sym].orgsize,rel_type);
|
|
end
|
|
else
|
|
begin
|
|
Comment(V_Error,'Error reading coff file');
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tcoffobjectinput.handle_symbols(data:TAsmObjectData);
|
|
var
|
|
sec : TSection;
|
|
size,
|
|
address,
|
|
i,nsyms,
|
|
symidx : longint;
|
|
sym : coffsymbol;
|
|
strname : string;
|
|
p : tasmsymbol;
|
|
bind : Tasmsymbind;
|
|
auxrec : array[0..17] of byte;
|
|
begin
|
|
with tcoffobjectdata(data) do
|
|
begin
|
|
nsyms:=FCoffSyms.Size div sizeof(CoffSymbol);
|
|
{ Allocate memory for symidx -> tasmsymbol table }
|
|
GetMem(FSymTbl,nsyms*sizeof(ttasmsymbolrec));
|
|
FillChar(FSymTbl^,nsyms*sizeof(ttasmsymbolrec),0);
|
|
{ Loop all symbols }
|
|
FCoffSyms.Seek(0);
|
|
symidx:=0;
|
|
while (symidx<nsyms) do
|
|
begin
|
|
FCoffSyms.Read(sym,sizeof(sym));
|
|
if plongint(@sym.name)^<>0 then
|
|
begin
|
|
move(sym.name,strname[1],8);
|
|
strname[9]:=#0;
|
|
end
|
|
else
|
|
begin
|
|
FCoffStrs.Seek(sym.strpos-4);
|
|
FCoffStrs.Read(strname[1],255);
|
|
strname[255]:=#0;
|
|
end;
|
|
strname[0]:=chr(strlen(@strname[1]));
|
|
if strname='' then
|
|
Internalerror(200205172);
|
|
bind:=AB_EXTERNAL;
|
|
sec:=sec_none;
|
|
size:=0;
|
|
address:=0;
|
|
case sym.typ of
|
|
COFF_SYM_GLOBAL :
|
|
begin
|
|
if sym.section=0 then
|
|
begin
|
|
if sym.value=0 then
|
|
bind:=AB_EXTERNAL
|
|
else
|
|
begin
|
|
bind:=AB_COMMON;
|
|
size:=sym.value;
|
|
end;
|
|
end
|
|
else
|
|
begin
|
|
bind:=AB_GLOBAL;
|
|
sec:=Fidx2sec[sym.section];
|
|
if assigned(sects[sec]) then
|
|
begin
|
|
if sym.value>=sects[sec].mempos then
|
|
address:=sym.value-sects[sec].mempos
|
|
else
|
|
internalerror(432432432);
|
|
end
|
|
else
|
|
internalerror(34243214);
|
|
end;
|
|
p:=TAsmSymbol.Create(strname,bind,AT_FUNCTION);
|
|
p.SetAddress(0,sec,address,size);
|
|
p.objectdata:=data;
|
|
symbols.insert(p);
|
|
end;
|
|
COFF_SYM_LABEL,
|
|
COFF_SYM_LOCAL :
|
|
begin
|
|
{ do not add constants (section=-1) }
|
|
if sym.section<>-1 then
|
|
begin
|
|
bind:=AB_LOCAL;
|
|
sec:=Fidx2sec[sym.section];
|
|
if assigned(sects[sec]) then
|
|
begin
|
|
if sym.value>=sects[sec].mempos then
|
|
address:=sym.value-sects[sec].mempos
|
|
else
|
|
internalerror(432432432);
|
|
end
|
|
else
|
|
internalerror(34243214);
|
|
p:=TAsmSymbol.Create(strname,bind,AT_FUNCTION);
|
|
p.SetAddress(0,sec,address,size);
|
|
p.objectdata:=data;
|
|
symbols.insert(p);
|
|
end;
|
|
end;
|
|
COFF_SYM_SECTION,
|
|
COFF_SYM_FUNCTION,
|
|
COFF_SYM_FILE :
|
|
;
|
|
else
|
|
internalerror(4342343);
|
|
end;
|
|
FSymTbl^[symidx].sym:=p;
|
|
FSymTbl^[symidx].orgsize:=size;
|
|
{ read aux records }
|
|
for i:=1 to sym.aux do
|
|
begin
|
|
FCoffSyms.Read(auxrec,sizeof(auxrec));
|
|
inc(symidx);
|
|
end;
|
|
inc(symidx);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function tcoffobjectinput.readobjectdata(data:TAsmObjectData):boolean;
|
|
var
|
|
strsize,
|
|
i : longint;
|
|
sec : TSection;
|
|
header : coffheader;
|
|
sechdr : coffsechdr;
|
|
secname : array[0..15] of char;
|
|
begin
|
|
result:=false;
|
|
FCoffSyms:=TDynamicArray.Create(symbolresize);
|
|
FCoffStrs:=TDynamicArray.Create(strsresize);
|
|
with tcoffobjectdata(data) do
|
|
begin
|
|
FillChar(Fidx2sec,sizeof(Fidx2sec),0);
|
|
{ Read COFF header }
|
|
if not reader.read(header,sizeof(coffheader)) then
|
|
begin
|
|
Comment(V_Error,'Error reading coff file');
|
|
exit;
|
|
end;
|
|
if header.mach<>$14c then
|
|
begin
|
|
Comment(V_Error,'Not a coff file');
|
|
exit;
|
|
end;
|
|
if header.nsects>255 then
|
|
begin
|
|
Comment(V_Error,'To many sections');
|
|
exit;
|
|
end;
|
|
{ Section headers }
|
|
for i:=1 to header.nsects do
|
|
begin
|
|
if not reader.read(sechdr,sizeof(sechdr)) then
|
|
begin
|
|
Comment(V_Error,'Error reading coff file');
|
|
exit;
|
|
end;
|
|
|
|
move(sechdr.name,secname,8);
|
|
secname[8]:=#0;
|
|
sec:=str2sec(strpas(secname));
|
|
if sec<>sec_none then
|
|
begin
|
|
Fidx2sec[i]:=sec;
|
|
createsection(sec);
|
|
if not win32 then
|
|
sects[sec].mempos:=sechdr.rvaofs;
|
|
TCoffObjectSection(sects[sec]).coffrelocs:=sechdr.nrelocs;
|
|
TCoffObjectSection(sects[sec]).coffrelocpos:=sechdr.relocpos;
|
|
sects[sec].datapos:=sechdr.datapos;
|
|
sects[sec].datasize:=sechdr.datasize;
|
|
sects[sec].memsize:=sechdr.datasize;
|
|
TCoffObjectSection(sects[sec]).orgmempos:=sects[sec].mempos;
|
|
sects[sec].flags:=sechdr.flags;
|
|
end
|
|
else
|
|
Comment(V_Warning,'skipping unsupported section '+strpas(sechdr.name));
|
|
end;
|
|
{ Symbols }
|
|
Reader.Seek(header.sympos);
|
|
if not Reader.ReadArray(FCoffSyms,header.syms*sizeof(CoffSymbol)) then
|
|
begin
|
|
Comment(V_Error,'Error reading coff file');
|
|
exit;
|
|
end;
|
|
{ Strings }
|
|
if not Reader.Read(strsize,4) then
|
|
begin
|
|
Comment(V_Error,'Error reading coff file');
|
|
exit;
|
|
end;
|
|
if strsize<4 then
|
|
begin
|
|
Comment(V_Error,'Error reading coff file');
|
|
exit;
|
|
end;
|
|
if not Reader.ReadArray(FCoffStrs,Strsize-4) then
|
|
begin
|
|
Comment(V_Error,'Error reading coff file');
|
|
exit;
|
|
end;
|
|
{ Insert all symbols }
|
|
handle_symbols(data);
|
|
{ Sections }
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if assigned(sects[sec]) and
|
|
(sec<>sec_bss) then
|
|
begin
|
|
Reader.Seek(sects[sec].datapos);
|
|
if not Reader.ReadArray(sects[sec].data,sects[sec].datasize) then
|
|
begin
|
|
Comment(V_Error,'Error reading coff file');
|
|
exit;
|
|
end;
|
|
end;
|
|
{ Relocs }
|
|
for sec:=low(TSection) to high(TSection) do
|
|
if assigned(sects[sec]) and
|
|
(TCoffObjectSection(sects[sec]).coffrelocs>0) then
|
|
begin
|
|
Reader.Seek(TCoffObjectSection(sects[sec]).coffrelocpos);
|
|
read_relocs(TCoffObjectSection(sects[sec]));
|
|
end;
|
|
end;
|
|
FCoffStrs.Free;
|
|
FCoffSyms.Free;
|
|
result:=true;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TCoffAssembler
|
|
****************************************************************************}
|
|
|
|
constructor TCoffAssembler.Create(smart:boolean);
|
|
begin
|
|
inherited Create(smart);
|
|
objectoutput:=tcoffobjectoutput.createdjgpp(smart);
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TPECoffAssembler
|
|
****************************************************************************}
|
|
|
|
constructor TPECoffAssembler.Create(smart:boolean);
|
|
begin
|
|
inherited Create(smart);
|
|
objectoutput:=tcoffobjectoutput.createwin32(smart);
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TCoffLinker
|
|
****************************************************************************}
|
|
|
|
constructor TCoffLinker.Create;
|
|
begin
|
|
inherited Create;
|
|
exeoutput:=tcoffexeoutput.createdjgpp;
|
|
end;
|
|
|
|
|
|
{*****************************************************************************
|
|
Initialize
|
|
*****************************************************************************}
|
|
|
|
const
|
|
as_i386_coff_info : tasminfo =
|
|
(
|
|
id : as_i386_coff;
|
|
idtxt : 'COFF';
|
|
asmbin : '';
|
|
asmcmd : '';
|
|
supported_target : system_i386_go32v2;
|
|
outputbinary : true;
|
|
allowdirect : false;
|
|
needar : false;
|
|
labelprefix_only_inside_procedure: false;
|
|
labelprefix : '.L';
|
|
comment : '';
|
|
secnames : ('',
|
|
'.text','.data','.bss',
|
|
'.idata$2','.idata$4','.idata$5','.idata$6','.idata$7','.edata',
|
|
'.stab','.stabstr','COMMON')
|
|
);
|
|
|
|
const
|
|
as_i386_pecoff_info : tasminfo =
|
|
(
|
|
id : as_i386_pecoff;
|
|
idtxt : 'PECOFF';
|
|
asmbin : '';
|
|
asmcmd : '';
|
|
supported_target : system_i386_win32;
|
|
outputbinary : true;
|
|
allowdirect : false;
|
|
needar : false;
|
|
labelprefix_only_inside_procedure: false;
|
|
labelprefix : '.L';
|
|
comment : '';
|
|
secnames : ('',
|
|
'.text','.data','.bss',
|
|
'.idata$2','.idata$4','.idata$5','.idata$6','.idata$7','.edata',
|
|
'.stab','.stabstr','COMMON')
|
|
);
|
|
|
|
as_i386_pecoffwdosx_info : tasminfo =
|
|
(
|
|
id : as_i386_pecoffwdosx;
|
|
idtxt : 'PEWDOSX';
|
|
asmbin : '';
|
|
asmcmd : '';
|
|
supported_target : system_i386_wdosx;
|
|
outputbinary : true;
|
|
allowdirect : false;
|
|
needar : false;
|
|
labelprefix_only_inside_procedure: false;
|
|
labelprefix : '.L';
|
|
comment : '';
|
|
secnames : ('',
|
|
'.text','.data','.bss',
|
|
'.idata$2','.idata$4','.idata$5','.idata$6','.idata$7','.edata',
|
|
'.stab','.stabstr','COMMON')
|
|
);
|
|
|
|
|
|
initialization
|
|
RegisterAssembler(as_i386_coff_info,TCoffAssembler);
|
|
RegisterAssembler(as_i386_pecoff_info,TPECoffAssembler);
|
|
RegisterAssembler(as_i386_pecoffwdosx_info,TPECoffAssembler);
|
|
end.
|
|
{
|
|
$Log$
|
|
Revision 1.27 2003-04-23 11:37:15 peter
|
|
* fix range check error after previous commit
|
|
|
|
Revision 1.26 2003/04/22 14:33:38 peter
|
|
* removed some notes/hints
|
|
|
|
Revision 1.25 2002/12/07 14:08:11 carl
|
|
* fix warning
|
|
|
|
Revision 1.24 2002/08/12 15:08:39 carl
|
|
+ stab register indexes for powerpc (moved from gdb to cpubase)
|
|
+ tprocessor enumeration moved to cpuinfo
|
|
+ linker in target_info is now a class
|
|
* many many updates for m68k (will soon start to compile)
|
|
- removed some ifdef or correct them for correct cpu
|
|
|
|
Revision 1.23 2002/07/26 21:15:38 florian
|
|
* rewrote the system handling
|
|
|
|
Revision 1.22 2002/07/01 18:46:24 peter
|
|
* internal linker
|
|
* reorganized aasm layer
|
|
|
|
Revision 1.21 2002/05/18 13:34:10 peter
|
|
* readded missing revisions
|
|
|
|
Revision 1.20 2002/05/16 19:46:39 carl
|
|
+ defines.inc -> fpcdefs.inc to avoid conflicts if compiling by hand
|
|
+ try to fix temp allocation (still in ifdef)
|
|
+ generic constructor calls
|
|
+ start of tassembler / tmodulebase class cleanup
|
|
|
|
Revision 1.19 2002/05/14 19:34:43 peter
|
|
* removed old logs and updated copyright year
|
|
|
|
Revision 1.18 2002/04/04 19:05:58 peter
|
|
* removed unused units
|
|
* use tlocation.size in cg.a_*loc*() routines
|
|
|
|
Revision 1.17 2002/04/04 18:38:30 carl
|
|
+ added wdosx support (patch from Pavel)
|
|
|
|
}
|