mirror of
https://gitlab.com/freepascal.org/fpc/source.git
synced 2025-11-04 13:39:39 +01:00
2655 lines
77 KiB
ObjectPascal
2655 lines
77 KiB
ObjectPascal
{
|
|
Copyright (c) 1998-2006 by Florian Klaempfl
|
|
|
|
This unit implements an abstract asmoutput class for all processor types
|
|
|
|
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.
|
|
|
|
****************************************************************************
|
|
}
|
|
{ @abstract(This unit implements an abstract asm output class for all processor types)
|
|
This unit implements an abstract assembler output class for all processors, these
|
|
are then overridden for each assembler writer to actually write the data in these
|
|
classes to an assembler file.
|
|
}
|
|
|
|
unit aasmtai;
|
|
|
|
{$i fpcdefs.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
cutils,cclasses,
|
|
globtype,systems,
|
|
cpuinfo,cpubase,
|
|
cgbase,cgutils,
|
|
symtype,
|
|
aasmbase,aasmdata,ogbase;
|
|
|
|
type
|
|
{ keep the number of elements in this enumeration less or equal than 32 as long
|
|
as FPC knows only 4 byte and 32 byte sets (FK) }
|
|
taitype = (
|
|
ait_none,
|
|
ait_align,
|
|
ait_section,
|
|
ait_comment,
|
|
ait_string,
|
|
ait_instruction,
|
|
ait_datablock,
|
|
ait_symbol,
|
|
{ needed to calc the size of a symbol }
|
|
ait_symbol_end,
|
|
ait_directive,
|
|
ait_label,
|
|
ait_const,
|
|
ait_real_32bit,
|
|
ait_real_64bit,
|
|
ait_real_80bit,
|
|
ait_comp_64bit,
|
|
ait_real_128bit,
|
|
ait_stab,
|
|
ait_force_line,
|
|
ait_function_name,
|
|
{$ifdef alpha}
|
|
{ the follow is for the DEC Alpha }
|
|
ait_frame,
|
|
ait_ent,
|
|
{$endif alpha}
|
|
{$ifdef ia64}
|
|
ait_bundle,
|
|
ait_stop,
|
|
{$endif ia64}
|
|
{$ifdef m68k}
|
|
ait_labeled_instruction,
|
|
{$endif m68k}
|
|
{$ifdef arm}
|
|
ait_thumb_func,
|
|
{$endif arm}
|
|
{ used to split into tiny assembler files }
|
|
ait_cutobject,
|
|
ait_regalloc,
|
|
ait_tempalloc,
|
|
{ used to mark assembler blocks and inlined functions }
|
|
ait_marker,
|
|
{ used to describe a new location of a variable }
|
|
ait_varloc,
|
|
{ SEH directives used in ARM,MIPS and x86_64 COFF targets }
|
|
ait_seh_directive
|
|
);
|
|
|
|
taiconst_type = (
|
|
aitconst_128bit,
|
|
aitconst_64bit,
|
|
aitconst_32bit,
|
|
aitconst_16bit,
|
|
aitconst_8bit,
|
|
aitconst_sleb128bit,
|
|
aitconst_uleb128bit,
|
|
{ win32 only }
|
|
aitconst_rva_symbol,
|
|
aitconst_secrel32_symbol,
|
|
{ darwin only }
|
|
{ From gcc/config/darwin.c (darwin_asm_output_dwarf_delta):
|
|
***
|
|
Output a difference of two labels that will be an assembly time
|
|
constant if the two labels are local. (.long lab1-lab2 will be
|
|
very different if lab1 is at the boundary between two sections; it
|
|
will be relocated according to the second section, not the first,
|
|
so one ends up with a difference between labels in different
|
|
sections, which is bad in the dwarf2 eh context for instance.)
|
|
***
|
|
We cannot use this everywhere, because older versions of the
|
|
darwin assembler don't support the construct used for these
|
|
relsyms (nor do they support dwarf, for that matter)
|
|
}
|
|
aitconst_darwin_dwarf_delta64,
|
|
aitconst_darwin_dwarf_delta32,
|
|
{ ARM Thumb-2 only }
|
|
aitconst_half16bit { used for table jumps. The actual value is the 16bit value shifted left once }
|
|
);
|
|
|
|
const
|
|
{$ifdef cpu64bitaddr}
|
|
aitconst_ptr = aitconst_64bit;
|
|
{$else cpu64bitaddr}
|
|
aitconst_ptr = aitconst_32bit;
|
|
{$endif cpu64bitaddr}
|
|
|
|
{$ifdef cpu64bitalu}
|
|
aitconst_aint = aitconst_64bit;
|
|
{$else cpu64bitaddr}
|
|
aitconst_aint = aitconst_32bit;
|
|
{$endif cpu64bitaddr}
|
|
|
|
taitypestr : array[taitype] of string[24] = (
|
|
'<none>',
|
|
'align',
|
|
'section',
|
|
'comment',
|
|
'string',
|
|
'instruction',
|
|
'datablock',
|
|
'symbol',
|
|
'symbol_end',
|
|
'symbol_directive',
|
|
'label',
|
|
'const',
|
|
'real_32bit',
|
|
'real_64bit',
|
|
'real_80bit',
|
|
'comp_64bit',
|
|
'real_128bit',
|
|
'stab',
|
|
'force_line',
|
|
'function_name',
|
|
{$ifdef alpha}
|
|
{ the follow is for the DEC Alpha }
|
|
'frame',
|
|
'ent',
|
|
{$endif alpha}
|
|
{$ifdef ia64}
|
|
'bundle',
|
|
'stop',
|
|
{$endif ia64}
|
|
{$ifdef m68k}
|
|
'labeled_instr',
|
|
{$endif m68k}
|
|
{$ifdef arm}
|
|
'thumb_func',
|
|
{$endif arm}
|
|
'cut',
|
|
'regalloc',
|
|
'tempalloc',
|
|
'marker',
|
|
'varloc',
|
|
'seh_directive'
|
|
);
|
|
|
|
type
|
|
{ Types of operand }
|
|
toptype=(top_none,top_reg,top_ref,top_const,top_bool,top_local
|
|
{$ifdef arm}
|
|
{ ARM only }
|
|
,top_regset
|
|
,top_shifterop
|
|
,top_conditioncode
|
|
,top_modeflags
|
|
{$endif arm}
|
|
{$ifdef m68k}
|
|
{ m68k only }
|
|
,top_regset
|
|
{$endif m68k}
|
|
{ i386 only});
|
|
|
|
{ kinds of operations that an instruction can perform on an operand }
|
|
topertype = (operand_read,operand_write,operand_readwrite);
|
|
|
|
tlocaloper = record
|
|
localsym : pointer;
|
|
localsymderef : tderef;
|
|
localsymofs : longint;
|
|
localindexreg : tregister;
|
|
localscale : byte;
|
|
localgetoffset,
|
|
localforceref : boolean
|
|
end;
|
|
plocaloper = ^tlocaloper;
|
|
|
|
{ please keep the size of this record <=12 bytes and keep it properly aligned }
|
|
toper = record
|
|
ot : longint;
|
|
case typ : toptype of
|
|
top_none : ();
|
|
top_reg : (reg:tregister);
|
|
top_ref : (ref:preference);
|
|
top_const : (val:tcgint);
|
|
top_bool : (b:boolean);
|
|
{ local varsym that will be inserted in pass_generate_code }
|
|
top_local : (localoper:plocaloper);
|
|
{$ifdef arm}
|
|
top_regset : (regset:^tcpuregisterset; regtyp: tregistertype; subreg: tsubregister);
|
|
top_shifterop : (shifterop : pshifterop);
|
|
top_conditioncode : (cc : TAsmCond);
|
|
top_modeflags : (modeflags : tcpumodeflags);
|
|
{$endif arm}
|
|
{$ifdef m68k}
|
|
top_regset : (regset:^tcpuregisterset);
|
|
{$endif m68k}
|
|
end;
|
|
poper=^toper;
|
|
|
|
const
|
|
{ ait_* types which don't result in executable code or which don't influence
|
|
the way the program runs/behaves, but which may be encountered by the
|
|
optimizer (= if it's sometimes added to the exprasm list). Update if you add
|
|
a new ait type! }
|
|
SkipInstr = [ait_comment, ait_symbol,ait_section
|
|
,ait_stab, ait_function_name, ait_force_line
|
|
,ait_regalloc, ait_tempalloc, ait_symbol_end, ait_directive
|
|
,ait_varloc,ait_seh_directive];
|
|
|
|
{ ait_* types which do not have line information (and hence which are of type
|
|
tai, otherwise, they are of type tailineinfo }
|
|
SkipLineInfo =[ait_label,
|
|
ait_regalloc,ait_tempalloc,
|
|
ait_stab,ait_function_name,
|
|
ait_cutobject,ait_marker,ait_varloc,ait_align,ait_section,ait_comment,
|
|
ait_const,
|
|
{$ifdef arm}
|
|
ait_thumb_func,
|
|
{$endif arm}
|
|
ait_real_32bit,ait_real_64bit,ait_real_80bit,ait_comp_64bit,ait_real_128bit,
|
|
ait_symbol,
|
|
ait_seh_directive
|
|
];
|
|
|
|
|
|
type
|
|
{ cut type, required for alphanumeric ordering of the assembler filenames }
|
|
TCutPlace=(cut_normal,cut_begin,cut_end);
|
|
|
|
TAsmMarker = (
|
|
mark_NoPropInfoStart,mark_NoPropInfoEnd,
|
|
mark_AsmBlockStart,mark_AsmBlockEnd,
|
|
mark_NoLineInfoStart,mark_NoLineInfoEnd,mark_BlockStart,
|
|
mark_Position
|
|
);
|
|
|
|
TRegAllocType = (ra_alloc,ra_dealloc,ra_sync,ra_resize);
|
|
|
|
TStabType = (stab_stabs,stab_stabn,stab_stabd);
|
|
|
|
TAsmDirective=(
|
|
asd_indirect_symbol,
|
|
asd_extern,asd_nasm_import, asd_toc_entry,
|
|
asd_reference,asd_no_dead_strip,asd_weak_reference,asd_lazy_reference,
|
|
asd_weak_definition
|
|
);
|
|
|
|
TAsmSehDirective=(
|
|
ash_proc,ash_endproc,
|
|
ash_endprologue,ash_handler,ash_handlerdata,
|
|
ash_eh,ash_32,ash_no32,
|
|
ash_setframe,ash_stackalloc,ash_pushreg,
|
|
ash_savereg,ash_savexmm,ash_pushframe
|
|
);
|
|
|
|
|
|
const
|
|
regallocstr : array[tregalloctype] of string[10]=('allocated','released','sync','resized');
|
|
tempallocstr : array[boolean] of string[10]=('released','allocated');
|
|
stabtypestr : array[TStabType] of string[5]=('stabs','stabn','stabd');
|
|
directivestr : array[TAsmDirective] of string[23]=(
|
|
'indirect_symbol',
|
|
'extern','nasm_import', 'tc', 'reference',
|
|
'no_dead_strip','weak_reference','lazy_reference','weak_definition'
|
|
);
|
|
sehdirectivestr : array[TAsmSehDirective] of string[16]=(
|
|
'.seh_proc','.seh_endproc',
|
|
'.seh_endprologue','.seh_handler','.seh_handlerdata',
|
|
'.seh_eh','.seh_32','seh_no32',
|
|
'.seh_setframe','.seh_stackalloc','.seh_pushreg',
|
|
'.seh_savereg','.seh_savexmm','.seh_pushframe'
|
|
);
|
|
|
|
type
|
|
{ abstract assembler item }
|
|
tai = class(TLinkedListItem)
|
|
{$ifndef NOOPT}
|
|
{ pointer to record with optimizer info about this tai object }
|
|
optinfo : pointer;
|
|
{$endif NOOPT}
|
|
typ : taitype;
|
|
constructor Create;
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);virtual;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);virtual;
|
|
procedure buildderefimpl;virtual;
|
|
procedure derefimpl;virtual;
|
|
end;
|
|
|
|
{ abstract assembler item with line information }
|
|
tailineinfo = class(tai)
|
|
fileinfo : tfileposinfo;
|
|
constructor Create;
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
end;
|
|
|
|
tai_simple = class(tai)
|
|
constructor create(_typ : taitype);
|
|
end;
|
|
|
|
taiclass = class of tai;
|
|
|
|
taiclassarray = array[taitype] of taiclass;
|
|
|
|
{ Generates an assembler string }
|
|
tai_string = class(tailineinfo)
|
|
str : pchar;
|
|
{ extra len so the string can contain an \0 }
|
|
len : longint;
|
|
constructor Create(const _str : string);
|
|
constructor Create_pchar(_str : pchar;length : longint);
|
|
destructor Destroy;override;
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
function getcopy:tlinkedlistitem;override;
|
|
end;
|
|
|
|
{ Generates a common label }
|
|
tai_symbol = class(tai)
|
|
sym : tasmsymbol;
|
|
value : puint;
|
|
size : longint;
|
|
is_global,
|
|
has_value : boolean;
|
|
constructor Create(_sym:tasmsymbol;siz:longint);
|
|
constructor Create_Global(_sym:tasmsymbol;siz:longint);
|
|
constructor Createname(const _name : string;_symtyp:Tasmsymtype;siz:longint);
|
|
constructor Createname_global(const _name : string;_symtyp:Tasmsymtype;siz:longint);
|
|
constructor Createname_global_value(const _name : string;_symtyp:Tasmsymtype;siz:longint;val:ptruint);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
procedure derefimpl;override;
|
|
end;
|
|
|
|
tai_symbol_end = class(tailineinfo)
|
|
sym : tasmsymbol;
|
|
constructor Create(_sym:tasmsymbol);
|
|
constructor Createname(const _name : string);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
procedure derefimpl;override;
|
|
end;
|
|
|
|
tai_directive = class(tailineinfo)
|
|
name : pshortstring;
|
|
directive : TAsmDirective;
|
|
constructor Create(_directive:TAsmDirective;const _name:string);
|
|
destructor Destroy;override;
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
end;
|
|
|
|
{ Generates an assembler label }
|
|
tai_label = class(tai)
|
|
is_global : boolean;
|
|
labsym : tasmlabel;
|
|
constructor Create(_labsym : tasmlabel);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
procedure derefimpl;override;
|
|
end;
|
|
|
|
{ Generates an assembler comment }
|
|
tai_comment = class(tai)
|
|
str : pchar;
|
|
constructor Create(_str : pchar);
|
|
destructor Destroy; override;
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
function getcopy:tlinkedlistitem;override;
|
|
end;
|
|
|
|
|
|
{ Generates a section / segment directive }
|
|
tai_section = class(tai)
|
|
sectype : TAsmSectiontype;
|
|
secorder : TasmSectionorder;
|
|
secalign : byte;
|
|
name : pshortstring;
|
|
sec : TObjSection; { used in binary writer }
|
|
destructor Destroy;override;
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
{$push}{$warnings off}
|
|
private
|
|
{ this constructor is made private on purpose }
|
|
{ because sections should be created via new_section() }
|
|
constructor Create(Asectype:TAsmSectiontype;const Aname:string;Aalign:byte;Asecorder:TasmSectionorder=secorder_default);
|
|
{$pop}
|
|
end;
|
|
|
|
|
|
{ Generates an uninitializised data block }
|
|
tai_datablock = class(tailineinfo)
|
|
is_global : boolean;
|
|
sym : tasmsymbol;
|
|
size : asizeint;
|
|
constructor Create(const _name : string;_size : aint);
|
|
constructor Create_global(const _name : string;_size : asizeint);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
procedure derefimpl;override;
|
|
end;
|
|
|
|
|
|
{ Generates an integer const }
|
|
tai_const = class(tai)
|
|
sym,
|
|
endsym : tasmsymbol;
|
|
{ if symbols and offset are provided the symofs is used,
|
|
the value is calculated during assembling }
|
|
symofs,
|
|
value : int64;
|
|
consttype : taiconst_type;
|
|
{ we use for the 128bit int64/qword for now because I can't imagine a
|
|
case where we need 128 bit now (FK) }
|
|
constructor Create(_typ:taiconst_type;_value : int64);
|
|
constructor Create_128bit(_value : int64);
|
|
constructor Create_64bit(_value : int64);
|
|
constructor Create_32bit(_value : longint);
|
|
constructor Create_16bit(_value : word);
|
|
constructor Create_8bit(_value : byte);
|
|
constructor Create_char(size: integer; _value: dword);
|
|
constructor Create_sleb128bit(_value : int64);
|
|
constructor Create_uleb128bit(_value : qword);
|
|
constructor Create_aint(_value : aint);
|
|
constructor Create_pint(_value : pint);
|
|
constructor Create_sym(_sym:tasmsymbol);
|
|
constructor Create_type_sym(_typ:taiconst_type;_sym:tasmsymbol);
|
|
constructor Create_sym_offset(_sym:tasmsymbol;ofs:aint);
|
|
constructor Create_rel_sym(_typ:taiconst_type;_sym,_endsym:tasmsymbol);
|
|
constructor Create_rva_sym(_sym:tasmsymbol);
|
|
constructor Createname(const name:string;ofs:aint);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
procedure derefimpl;override;
|
|
function getcopy:tlinkedlistitem;override;
|
|
function size:longint;
|
|
end;
|
|
|
|
{ Generates a single float (32 bit real) }
|
|
tai_real_32bit = class(tai)
|
|
value : ts32real;
|
|
constructor Create(_value : ts32real);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
end;
|
|
|
|
tformatoptions = (fo_none,fo_hiloswapped);
|
|
|
|
{ Generates a double float (64 bit real) }
|
|
tai_real_64bit = class(tai)
|
|
value : ts64real;
|
|
{$ifdef ARM}
|
|
formatoptions : tformatoptions;
|
|
constructor Create_hiloswapped(_value : ts64real);
|
|
{$endif ARM}
|
|
constructor Create(_value : ts64real);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
end;
|
|
|
|
|
|
{ Generates an extended float (80 bit real) }
|
|
tai_real_80bit = class(tai)
|
|
value : ts80real;
|
|
savesize : byte;
|
|
constructor Create(_value : ts80real; _savesize: byte);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
end;
|
|
|
|
|
|
{ Generates an float128 (128 bit real) }
|
|
tai_real_128bit = class(tai)
|
|
value : ts128real;
|
|
constructor Create(_value : ts128real);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
end;
|
|
|
|
{ Generates a comp int (integer over 64 bits)
|
|
|
|
This is Intel 80x86 specific, and is not
|
|
really supported on other processors.
|
|
}
|
|
tai_comp_64bit = class(tai)
|
|
value : ts64comp;
|
|
constructor Create(_value : ts64comp);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
end;
|
|
|
|
{ tai_stab }
|
|
|
|
tai_stab = class(tai)
|
|
str : pchar;
|
|
stabtype : TStabType;
|
|
constructor Create(_stabtype:TStabType;_str : pchar);
|
|
constructor Create_str(_stabtype:TStabType;const s:string);
|
|
constructor create_ansistr(_stabtype: TStabType; const s: ansistring);
|
|
destructor Destroy;override;
|
|
end;
|
|
|
|
tai_force_line = class(tailineinfo)
|
|
constructor Create;
|
|
end;
|
|
|
|
tai_function_name = class(tai)
|
|
funcname : pshortstring;
|
|
constructor create(const s:string);
|
|
destructor destroy;override;
|
|
end;
|
|
|
|
{ Insert a cut to split assembler into several smaller files }
|
|
tai_cutobject = class(tai)
|
|
place : tcutplace;
|
|
constructor Create;
|
|
constructor Create_begin;
|
|
constructor Create_end;
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
end;
|
|
|
|
{ Insert a marker for assembler and inline blocks }
|
|
tai_marker = class(tai)
|
|
Kind: TAsmMarker;
|
|
Constructor Create(_Kind: TAsmMarker);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
end;
|
|
|
|
tai_tempalloc = class(tai)
|
|
allocation : boolean;
|
|
{$ifdef EXTDEBUG}
|
|
problem : pshortstring;
|
|
{$endif EXTDEBUG}
|
|
temppos,
|
|
tempsize : longint;
|
|
constructor alloc(pos,size:longint);
|
|
constructor dealloc(pos,size:longint);
|
|
{$ifdef EXTDEBUG}
|
|
constructor allocinfo(pos,size:longint;const st:string);
|
|
{$endif EXTDEBUG}
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
destructor destroy;override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
end;
|
|
|
|
tai_regalloc = class(tai)
|
|
reg : tregister;
|
|
ratype : TRegAllocType;
|
|
{ reg(de)alloc belongs to this instruction, this
|
|
is only used for automatic inserted (de)alloc for
|
|
imaginary register and required for spilling code }
|
|
instr : tai;
|
|
constructor alloc(r : tregister;ainstr:tai);
|
|
constructor dealloc(r : tregister;ainstr:tai);
|
|
constructor sync(r : tregister);
|
|
constructor resize(r : tregister);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
end;
|
|
|
|
tadd_reg_instruction_proc=procedure(instr:Tai;r:tregister) of object;
|
|
|
|
{ Class template for assembler instructions
|
|
}
|
|
tai_cpu_abstract = class(tailineinfo)
|
|
protected
|
|
procedure ppuloadoper(ppufile:tcompilerppufile;var o:toper);virtual;
|
|
procedure ppuwriteoper(ppufile:tcompilerppufile;const o:toper);virtual;
|
|
procedure ppubuildderefimploper(var o:toper);virtual;abstract;
|
|
procedure ppuderefoper(var o:toper);virtual;abstract;
|
|
public
|
|
{ Condition flags for instruction }
|
|
condition : TAsmCond;
|
|
{ Number of operands to instruction }
|
|
ops : byte;
|
|
{ Number of allocate oper structures }
|
|
opercnt : byte;
|
|
{ Operands of instruction }
|
|
oper : array[0..max_operands-1] of poper;
|
|
{ Actual opcode of instruction }
|
|
opcode : tasmop;
|
|
{$ifdef x86}
|
|
segprefix : tregister;
|
|
{$endif x86}
|
|
{ true if instruction is a jmp }
|
|
is_jmp : boolean; { is this instruction a jump? (needed for optimizer) }
|
|
Constructor Create(op : tasmop);virtual;
|
|
Destructor Destroy;override;
|
|
function getcopy:TLinkedListItem;override;
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
procedure buildderefimpl;override;
|
|
procedure derefimpl;override;
|
|
procedure SetCondition(const c:TAsmCond);
|
|
procedure allocate_oper(opers:longint);
|
|
procedure loadconst(opidx:longint;l:aint);
|
|
procedure loadsymbol(opidx:longint;s:tasmsymbol;sofs:longint);
|
|
procedure loadlocal(opidx:longint;s:pointer;sofs:longint;indexreg:tregister;scale:byte;getoffset,forceref:boolean);
|
|
procedure loadref(opidx:longint;const r:treference);
|
|
procedure loadreg(opidx:longint;r:tregister);
|
|
procedure loadoper(opidx:longint;o:toper);
|
|
procedure clearop(opidx:longint);
|
|
procedure freeop(opidx:longint);
|
|
{ register allocator }
|
|
function is_same_reg_move(regtype: Tregistertype):boolean;virtual;
|
|
function spilling_get_operation_type(opnr: longint): topertype;virtual;
|
|
function spilling_get_operation_type_ref(opnr: longint; reg: tregister): topertype;virtual;
|
|
|
|
function Pass1(objdata:TObjData):longint;virtual;
|
|
procedure Pass2(objdata:TObjData);virtual;
|
|
|
|
procedure resetpass1; virtual;
|
|
procedure resetpass2; virtual;
|
|
end;
|
|
tai_cpu_class = class of tai_cpu_abstract;
|
|
|
|
{ Buffer type used for alignment }
|
|
tfillbuffer = array[0..63] of char;
|
|
|
|
{ alignment for operator }
|
|
tai_align_abstract = class(tai)
|
|
aligntype : byte; { 1 = no align, 2 = word align, 4 = dword align }
|
|
fillsize : byte; { real size to fill }
|
|
fillop : byte; { value to fill with - optional }
|
|
use_op : boolean;
|
|
constructor Create(b:byte);virtual;
|
|
constructor Create_op(b: byte; _op: byte);virtual;
|
|
constructor Create_zeros(b:byte);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
function calculatefillbuf(var buf : tfillbuffer;executable : boolean):pchar;virtual;
|
|
end;
|
|
tai_align_class = class of tai_align_abstract;
|
|
|
|
tai_varloc = class(tai)
|
|
newlocation,
|
|
newlocationhi : tregister;
|
|
varsym : tsym;
|
|
constructor create(sym : tsym;loc : tregister);
|
|
constructor create64(sym : tsym;loc,lochi : tregister);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
procedure buildderefimpl;override;
|
|
procedure derefimpl;override;
|
|
end;
|
|
|
|
TSehDirectiveDatatype=(sd_none,sd_string,sd_reg,sd_offset,sd_regoffset);
|
|
|
|
TSehDirectiveData=record
|
|
case typ: TSehDirectiveDatatype of
|
|
sd_none: ();
|
|
sd_string: (name:pshortstring;flags:byte);
|
|
sd_reg,sd_offset,sd_regoffset: (reg:TRegister;offset:dword);
|
|
end;
|
|
|
|
tai_seh_directive = class(tai)
|
|
kind: TAsmSehDirective;
|
|
data: TSehDirectiveData;
|
|
constructor create(_kind:TAsmSehDirective);
|
|
constructor create_name(_kind:TAsmSehDirective;const _name: string);
|
|
constructor create_reg(_kind:TAsmSehDirective;r:TRegister);
|
|
constructor create_offset(_kind:TAsmSehDirective;ofs:dword);
|
|
constructor create_reg_offset(_kind:TAsmSehDirective;r:TRegister;ofs:dword);
|
|
constructor ppuload(t:taitype;ppufile:tcompilerppufile);override;
|
|
destructor destroy;override;
|
|
procedure ppuwrite(ppufile:tcompilerppufile);override;
|
|
procedure generate_code(objdata:TObjData);virtual;
|
|
property datatype: TSehDirectiveDatatype read data.typ;
|
|
end;
|
|
tai_seh_directive_class=class of tai_seh_directive;
|
|
|
|
var
|
|
{ array with all class types for tais }
|
|
aiclass : taiclassarray;
|
|
|
|
{ target specific tais, possibly overwritten in target specific aasmcpu }
|
|
cai_align : tai_align_class = tai_align_abstract;
|
|
cai_cpu : tai_cpu_class = tai_cpu_abstract;
|
|
cai_seh_directive: tai_seh_directive_class = tai_seh_directive;
|
|
|
|
{ hook to notify uses of registers }
|
|
add_reg_instruction_hook : tadd_reg_instruction_proc;
|
|
|
|
procedure maybe_new_object_file(list:TAsmList);
|
|
procedure new_section(list:TAsmList;Asectype:TAsmSectiontype;const Aname:string;Aalign:byte;Asecorder:TasmSectionorder=secorder_default);
|
|
procedure section_symbol_start(list:TAsmList;const Aname:string;Asymtyp:Tasmsymtype;
|
|
Aglobal:boolean;Asectype:TAsmSectiontype;Aalign:byte);
|
|
procedure section_symbol_end(list:TAsmList;const Aname:string);
|
|
|
|
function ppuloadai(ppufile:tcompilerppufile):tai;
|
|
procedure ppuwriteai(ppufile:tcompilerppufile;n:tai);
|
|
|
|
|
|
implementation
|
|
|
|
uses
|
|
SysUtils,
|
|
verbose,
|
|
globals,
|
|
fmodule;
|
|
|
|
const
|
|
pputaimarker = 254;
|
|
|
|
|
|
{****************************************************************************
|
|
Helpers
|
|
****************************************************************************}
|
|
|
|
procedure maybe_new_object_file(list:TAsmList);
|
|
begin
|
|
if create_smartlink_library then
|
|
list.concat(tai_cutobject.create);
|
|
end;
|
|
|
|
|
|
procedure new_section(list:TAsmList;Asectype:TAsmSectiontype;const Aname:string;Aalign:byte;Asecorder:TasmSectionorder=secorder_default);
|
|
begin
|
|
list.concat(tai_section.create(Asectype,Aname,Aalign,Asecorder));
|
|
list.concat(cai_align.create(Aalign));
|
|
end;
|
|
|
|
|
|
procedure section_symbol_start(list:TAsmList;const Aname:string;Asymtyp:Tasmsymtype;
|
|
Aglobal:boolean;Asectype:TAsmSectiontype;Aalign:byte);
|
|
begin
|
|
maybe_new_object_file(list);
|
|
new_section(list,Asectype,Aname,Aalign);
|
|
if Aglobal or
|
|
create_smartlink then
|
|
list.concat(tai_symbol.createname_global(Aname,Asymtyp,0))
|
|
else
|
|
list.concat(tai_symbol.createname(Aname,Asymtyp,0));
|
|
end;
|
|
|
|
|
|
procedure section_symbol_end(list:TAsmList;const Aname:string);
|
|
begin
|
|
list.concat(tai_symbol_end.createname(Aname));
|
|
end;
|
|
|
|
|
|
function ppuloadai(ppufile:tcompilerppufile):tai;
|
|
var
|
|
b : byte;
|
|
t : taitype;
|
|
begin
|
|
{ marker }
|
|
b:=ppufile.getbyte;
|
|
if b<>pputaimarker then
|
|
internalerror(200208181);
|
|
{ load nodetype }
|
|
t:=taitype(ppufile.getbyte);
|
|
if t<>ait_none then
|
|
begin
|
|
if t>high(taitype) then
|
|
internalerror(200208182);
|
|
if not assigned(aiclass[t]) then
|
|
internalerror(200208183);
|
|
{writeln('taiload: ',taitypestr[t]);}
|
|
{ generate tai of the correct class }
|
|
ppuloadai:=aiclass[t].ppuload(t,ppufile);
|
|
end
|
|
else
|
|
ppuloadai:=nil;
|
|
end;
|
|
|
|
|
|
procedure ppuwriteai(ppufile:tcompilerppufile;n:tai);
|
|
begin
|
|
{ marker, read by ppuloadnode }
|
|
ppufile.putbyte(pputaimarker);
|
|
if assigned(n) then
|
|
begin
|
|
{ type, read by ppuloadnode }
|
|
ppufile.putbyte(byte(n.typ));
|
|
{writeln('taiwrite: ',taitypestr[n.typ]);}
|
|
n.ppuwrite(ppufile);
|
|
end
|
|
else
|
|
ppufile.putbyte(byte(ait_none));
|
|
end;
|
|
|
|
|
|
constructor tai_varloc.create(sym: tsym; loc: tregister);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_varloc;
|
|
newlocation:=loc;
|
|
newlocationhi:=NR_NO;
|
|
varsym:=sym;
|
|
end;
|
|
|
|
|
|
constructor tai_varloc.create64(sym: tsym; loc: tregister;lochi : tregister);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_varloc;
|
|
newlocation:=loc;
|
|
newlocationhi:=lochi;
|
|
varsym:=sym;
|
|
end;
|
|
|
|
|
|
constructor tai_varloc.ppuload(t: taitype; ppufile: tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t, ppufile);
|
|
end;
|
|
|
|
|
|
procedure tai_varloc.ppuwrite(ppufile: tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
end;
|
|
|
|
|
|
procedure tai_varloc.buildderefimpl;
|
|
begin
|
|
inherited buildderefimpl;
|
|
end;
|
|
|
|
|
|
procedure tai_varloc.derefimpl;
|
|
begin
|
|
inherited derefimpl;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI
|
|
****************************************************************************}
|
|
|
|
constructor tai.Create;
|
|
begin
|
|
{$ifndef NOOPT}
|
|
optinfo:=nil;
|
|
{$endif NOOPT}
|
|
end;
|
|
|
|
|
|
constructor tai.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
typ:=t;
|
|
{$ifndef NOOPT}
|
|
optinfo:=nil;
|
|
{$endif}
|
|
end;
|
|
|
|
|
|
procedure tai.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
end;
|
|
|
|
|
|
procedure tai.buildderefimpl;
|
|
begin
|
|
end;
|
|
|
|
|
|
procedure tai.derefimpl;
|
|
begin
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAILINEINFO
|
|
****************************************************************************}
|
|
|
|
constructor tailineinfo.create;
|
|
begin
|
|
inherited create;
|
|
fileinfo:=current_filepos;
|
|
end;
|
|
|
|
|
|
constructor tailineinfo.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
ppufile.getposinfo(fileinfo);
|
|
end;
|
|
|
|
|
|
procedure tailineinfo.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putposinfo(fileinfo);
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_SIMPLE
|
|
****************************************************************************}
|
|
|
|
constructor tai_simple.create(_typ : taitype);
|
|
begin
|
|
inherited create;
|
|
typ:=_typ;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_SECTION
|
|
****************************************************************************}
|
|
|
|
constructor tai_section.Create(Asectype:TAsmSectiontype;const Aname:string;Aalign:byte;Asecorder:TasmSectionorder=secorder_default);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_section;
|
|
sectype:=asectype;
|
|
secalign:=Aalign;
|
|
secorder:=Asecorder;
|
|
name:=stringdup(Aname);
|
|
sec:=nil;
|
|
end;
|
|
|
|
|
|
constructor tai_section.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
sectype:=TAsmSectiontype(ppufile.getbyte);
|
|
secalign:=ppufile.getbyte;
|
|
name:=stringdup(ppufile.getstring);
|
|
sec:=nil;
|
|
end;
|
|
|
|
|
|
destructor tai_section.Destroy;
|
|
begin
|
|
stringdispose(name);
|
|
end;
|
|
|
|
|
|
procedure tai_section.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putbyte(byte(sectype));
|
|
ppufile.putbyte(secalign);
|
|
ppufile.putstring(name^);
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_DATABLOCK
|
|
****************************************************************************}
|
|
|
|
constructor tai_datablock.Create(const _name : string;_size : aint);
|
|
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_datablock;
|
|
sym:=current_asmdata.DefineAsmSymbol(_name,AB_LOCAL,AT_DATA);
|
|
{ keep things aligned }
|
|
if _size<=0 then
|
|
_size:=sizeof(aint);
|
|
size:=_size;
|
|
is_global:=false;
|
|
end;
|
|
|
|
|
|
constructor tai_datablock.Create_global(const _name : string;_size : asizeint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_datablock;
|
|
sym:=current_asmdata.DefineAsmSymbol(_name,AB_GLOBAL,AT_DATA);
|
|
{ keep things aligned }
|
|
if _size<=0 then
|
|
_size:=sizeof(aint);
|
|
size:=_size;
|
|
is_global:=true;
|
|
end;
|
|
|
|
|
|
constructor tai_datablock.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited Create;
|
|
sym:=ppufile.getasmsymbol;
|
|
size:=ppufile.getaint;
|
|
is_global:=boolean(ppufile.getbyte);
|
|
end;
|
|
|
|
|
|
procedure tai_datablock.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putasmsymbol(sym);
|
|
ppufile.putaint(size);
|
|
ppufile.putbyte(byte(is_global));
|
|
end;
|
|
|
|
|
|
procedure tai_datablock.derefimpl;
|
|
begin
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_SYMBOL
|
|
****************************************************************************}
|
|
|
|
constructor tai_symbol.Create(_sym:tasmsymbol;siz:longint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_symbol;
|
|
sym:=_sym;
|
|
size:=siz;
|
|
sym.bind:=AB_LOCAL;
|
|
is_global:=false;
|
|
end;
|
|
|
|
|
|
constructor tai_symbol.Create_global(_sym:tasmsymbol;siz:longint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_symbol;
|
|
sym:=_sym;
|
|
size:=siz;
|
|
{ don't override PRIVATE_EXTERN with GLOBAL }
|
|
if not(sym.bind in [AB_GLOBAL,AB_PRIVATE_EXTERN]) then
|
|
sym.bind:=AB_GLOBAL;
|
|
is_global:=true;
|
|
end;
|
|
|
|
|
|
constructor tai_symbol.Createname(const _name : string;_symtyp:Tasmsymtype;siz:longint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_symbol;
|
|
sym:=current_asmdata.DefineAsmSymbol(_name,AB_LOCAL,_symtyp);
|
|
size:=siz;
|
|
is_global:=false;
|
|
end;
|
|
|
|
|
|
constructor tai_symbol.Createname_global(const _name : string;_symtyp:Tasmsymtype;siz:longint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_symbol;
|
|
sym:=current_asmdata.DefineAsmSymbol(_name,AB_GLOBAL,_symtyp);
|
|
size:=siz;
|
|
is_global:=true;
|
|
end;
|
|
|
|
|
|
constructor tai_symbol.createname_global_value(const _name: string;_symtyp: tasmsymtype; siz: longint; val: ptruint);
|
|
begin
|
|
Createname_global(_name,_symtyp,siz);
|
|
value:=val;
|
|
has_value:=true;
|
|
end;
|
|
|
|
|
|
constructor tai_symbol.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
sym:=ppufile.getasmsymbol;
|
|
size:=ppufile.getlongint;
|
|
is_global:=boolean(ppufile.getbyte);
|
|
end;
|
|
|
|
|
|
procedure tai_symbol.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putasmsymbol(sym);
|
|
ppufile.putlongint(size);
|
|
ppufile.putbyte(byte(is_global));
|
|
end;
|
|
|
|
|
|
procedure tai_symbol.derefimpl;
|
|
begin
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_SYMBOL_END
|
|
****************************************************************************}
|
|
|
|
constructor tai_symbol_end.Create(_sym:tasmsymbol);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_symbol_end;
|
|
sym:=_sym;
|
|
end;
|
|
|
|
|
|
constructor tai_symbol_end.Createname(const _name : string);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_symbol_end;
|
|
sym:=current_asmdata.RefAsmSymbol(_name);
|
|
end;
|
|
|
|
|
|
constructor tai_symbol_end.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
sym:=ppufile.getasmsymbol;
|
|
end;
|
|
|
|
|
|
procedure tai_symbol_end.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putasmsymbol(sym);
|
|
end;
|
|
|
|
|
|
procedure tai_symbol_end.derefimpl;
|
|
begin
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_SYMBOL_END
|
|
****************************************************************************}
|
|
|
|
constructor tai_directive.Create(_directive:TAsmDirective;const _name:string);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_directive;
|
|
name:=stringdup(_name);
|
|
directive:=_directive;
|
|
end;
|
|
|
|
|
|
destructor tai_directive.Destroy;
|
|
begin
|
|
stringdispose(name);
|
|
end;
|
|
|
|
|
|
constructor tai_directive.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
name:=stringdup(ppufile.getstring);
|
|
directive:=TAsmDirective(ppufile.getbyte);
|
|
end;
|
|
|
|
|
|
procedure tai_directive.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putstring(name^);
|
|
ppufile.putbyte(byte(directive));
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_CONST
|
|
****************************************************************************}
|
|
|
|
constructor tai_const.Create(_typ:taiconst_type;_value : int64);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=_typ;
|
|
value:=_value;
|
|
sym:=nil;
|
|
endsym:=nil;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_128bit(_value : int64);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=aitconst_128bit;
|
|
value:=_value;
|
|
sym:=nil;
|
|
endsym:=nil;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_64bit(_value : int64);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=aitconst_64bit;
|
|
value:=_value;
|
|
sym:=nil;
|
|
endsym:=nil;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_32bit(_value : longint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=aitconst_32bit;
|
|
value:=_value;
|
|
sym:=nil;
|
|
endsym:=nil;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_16bit(_value : word);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=aitconst_16bit;
|
|
value:=_value;
|
|
sym:=nil;
|
|
endsym:=nil;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_8bit(_value : byte);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=aitconst_8bit;
|
|
value:=_value;
|
|
sym:=nil;
|
|
endsym:=nil;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_char(size: integer; _value: dword);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
case size of
|
|
1:
|
|
begin
|
|
consttype:=aitconst_8bit;
|
|
value:=byte(_value)
|
|
end;
|
|
2:
|
|
begin
|
|
consttype:=aitconst_16bit;
|
|
value:=word(_value)
|
|
end
|
|
else
|
|
InternalError(2010030701)
|
|
end
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_sleb128bit(_value : int64);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=aitconst_sleb128bit;
|
|
value:=_value;
|
|
sym:=nil;
|
|
endsym:=nil;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_uleb128bit(_value : qword);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=aitconst_uleb128bit;
|
|
value:=int64(_value);
|
|
sym:=nil;
|
|
endsym:=nil;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_aint(_value : aint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=aitconst_aint;
|
|
value:=_value;
|
|
sym:=nil;
|
|
endsym:=nil;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_pint(_value : pint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=aitconst_ptr;
|
|
value:=_value;
|
|
sym:=nil;
|
|
endsym:=nil;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_type_sym(_typ:taiconst_type;_sym:tasmsymbol);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=_typ;
|
|
sym:=_sym;
|
|
endsym:=nil;
|
|
value:=0;
|
|
{ update sym info }
|
|
if assigned(sym) then
|
|
sym.increfs;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_sym(_sym:tasmsymbol);
|
|
begin
|
|
self.create_sym_offset(_sym,0);
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_sym_offset(_sym:tasmsymbol;ofs:aint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_const;
|
|
consttype:=aitconst_ptr;
|
|
{ sym is allowed to be nil, this is used to write nil pointers }
|
|
sym:=_sym;
|
|
endsym:=nil;
|
|
{ store the original offset in symofs so that we can recalculate the
|
|
value field in the assembler }
|
|
symofs:=ofs;
|
|
value:=ofs;
|
|
{ update sym info }
|
|
if assigned(sym) then
|
|
sym.increfs;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_rel_sym(_typ:taiconst_type;_sym,_endsym:tasmsymbol);
|
|
begin
|
|
self.create_sym_offset(_sym,0);
|
|
consttype:=_typ;
|
|
endsym:=_endsym;
|
|
endsym.increfs;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Create_rva_sym(_sym:tasmsymbol);
|
|
begin
|
|
self.create_sym_offset(_sym,0);
|
|
consttype:=aitconst_rva_symbol;
|
|
end;
|
|
|
|
|
|
constructor tai_const.Createname(const name:string;ofs:aint);
|
|
begin
|
|
self.create_sym_offset(current_asmdata.RefAsmSymbol(name),ofs);
|
|
end;
|
|
|
|
|
|
constructor tai_const.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
consttype:=taiconst_type(ppufile.getbyte);
|
|
sym:=ppufile.getasmsymbol;
|
|
endsym:=ppufile.getasmsymbol;
|
|
value:=ppufile.getint64;
|
|
end;
|
|
|
|
|
|
procedure tai_const.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putbyte(byte(consttype));
|
|
ppufile.putasmsymbol(sym);
|
|
ppufile.putasmsymbol(endsym);
|
|
ppufile.putint64(value);
|
|
end;
|
|
|
|
|
|
procedure tai_const.derefimpl;
|
|
begin
|
|
end;
|
|
|
|
|
|
function tai_const.getcopy:tlinkedlistitem;
|
|
begin
|
|
getcopy:=inherited getcopy;
|
|
{ we need to increase the reference number }
|
|
sym.increfs;
|
|
if assigned(endsym) then
|
|
endsym.increfs;
|
|
end;
|
|
|
|
|
|
function tai_const.size:longint;
|
|
begin
|
|
case consttype of
|
|
aitconst_8bit :
|
|
result:=1;
|
|
aitconst_16bit :
|
|
result:=2;
|
|
aitconst_32bit,aitconst_darwin_dwarf_delta32:
|
|
result:=4;
|
|
aitconst_64bit,aitconst_darwin_dwarf_delta64:
|
|
result:=8;
|
|
aitconst_secrel32_symbol,
|
|
aitconst_rva_symbol :
|
|
if target_info.system=system_x86_64_win64 then
|
|
result:=sizeof(longint)
|
|
else
|
|
result:=sizeof(pint);
|
|
aitconst_uleb128bit :
|
|
result:=LengthUleb128(qword(value));
|
|
aitconst_sleb128bit :
|
|
result:=LengthSleb128(value);
|
|
aitconst_half16bit:
|
|
result:=2;
|
|
else
|
|
internalerror(200603253);
|
|
end;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_real_32bit
|
|
****************************************************************************}
|
|
|
|
constructor tai_real_32bit.Create(_value : ts32real);
|
|
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_real_32bit;
|
|
value:=_value;
|
|
end;
|
|
|
|
constructor tai_real_32bit.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
value:=ppufile.getreal;
|
|
end;
|
|
|
|
|
|
procedure tai_real_32bit.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putreal(value);
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_real_64bit
|
|
****************************************************************************}
|
|
|
|
constructor tai_real_64bit.Create(_value : ts64real);
|
|
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_real_64bit;
|
|
value:=_value;
|
|
end;
|
|
|
|
|
|
{$ifdef ARM}
|
|
constructor tai_real_64bit.Create_hiloswapped(_value : ts64real);
|
|
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_real_64bit;
|
|
value:=_value;
|
|
formatoptions:=fo_hiloswapped;
|
|
end;
|
|
{$endif ARM}
|
|
|
|
constructor tai_real_64bit.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
value:=ppufile.getreal;
|
|
{$ifdef ARM}
|
|
formatoptions:=tformatoptions(ppufile.getbyte);
|
|
{$endif ARM}
|
|
end;
|
|
|
|
|
|
procedure tai_real_64bit.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putreal(value);
|
|
{$ifdef ARM}
|
|
ppufile.putbyte(byte(formatoptions));
|
|
{$endif ARM}
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_real_80bit
|
|
****************************************************************************}
|
|
|
|
constructor tai_real_80bit.Create(_value : ts80real; _savesize: byte);
|
|
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_real_80bit;
|
|
value:=_value;
|
|
savesize:=_savesize;
|
|
end;
|
|
|
|
|
|
constructor tai_real_80bit.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
value:=ppufile.getreal;
|
|
savesize:=ppufile.getbyte;
|
|
end;
|
|
|
|
|
|
procedure tai_real_80bit.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putreal(value);
|
|
ppufile.putbyte(savesize);
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_real_80bit
|
|
****************************************************************************}
|
|
|
|
constructor tai_real_128bit.Create(_value : ts128real);
|
|
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_real_128bit;
|
|
value:=_value;
|
|
end;
|
|
|
|
|
|
constructor tai_real_128bit.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
value:=ppufile.getreal;
|
|
end;
|
|
|
|
|
|
procedure tai_real_128bit.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putreal(value);
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
Tai_comp_64bit
|
|
****************************************************************************}
|
|
|
|
constructor tai_comp_64bit.Create(_value : ts64comp);
|
|
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_comp_64bit;
|
|
value:=_value;
|
|
end;
|
|
|
|
|
|
constructor tai_comp_64bit.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
ppufile.putdata(value,sizeof(value));
|
|
end;
|
|
|
|
|
|
procedure tai_comp_64bit.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.getdata(value,sizeof(value));
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_STRING
|
|
****************************************************************************}
|
|
|
|
constructor tai_string.Create(const _str : string);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_string;
|
|
len:=length(_str);
|
|
getmem(str,len+1);
|
|
strpcopy(str,_str);
|
|
end;
|
|
|
|
|
|
constructor tai_string.Create_pchar(_str : pchar;length : longint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_string;
|
|
str:=_str;
|
|
len:=length;
|
|
end;
|
|
|
|
|
|
destructor tai_string.destroy;
|
|
begin
|
|
if str<>nil then
|
|
freemem(str);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
|
|
constructor tai_string.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
len:=ppufile.getlongint;
|
|
getmem(str,len);
|
|
ppufile.getdata(str^,len);
|
|
end;
|
|
|
|
|
|
procedure tai_string.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putlongint(len);
|
|
ppufile.putdata(str^,len);
|
|
end;
|
|
|
|
|
|
function tai_string.getcopy : tlinkedlistitem;
|
|
var
|
|
p : tlinkedlistitem;
|
|
begin
|
|
p:=inherited getcopy;
|
|
getmem(tai_string(p).str,len);
|
|
move(str^,tai_string(p).str^,len);
|
|
getcopy:=p;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_LABEL
|
|
****************************************************************************}
|
|
|
|
constructor tai_label.create(_labsym : tasmlabel);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_label;
|
|
labsym:=_labsym;
|
|
labsym.is_set:=true;
|
|
is_global:=(labsym.bind in [AB_GLOBAL,AB_PRIVATE_EXTERN]);
|
|
end;
|
|
|
|
|
|
constructor tai_label.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
labsym:=tasmlabel(ppufile.getasmsymbol);
|
|
is_global:=boolean(ppufile.getbyte);
|
|
end;
|
|
|
|
|
|
procedure tai_label.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putasmsymbol(labsym);
|
|
ppufile.putbyte(byte(is_global));
|
|
end;
|
|
|
|
|
|
procedure tai_label.derefimpl;
|
|
begin
|
|
labsym.is_set:=true;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
tai_comment comment to be inserted in the assembler file
|
|
****************************************************************************}
|
|
|
|
constructor tai_comment.Create(_str : pchar);
|
|
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_comment;
|
|
str:=_str;
|
|
end;
|
|
|
|
destructor tai_comment.destroy;
|
|
|
|
begin
|
|
freemem(str);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
constructor tai_comment.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
var
|
|
len : longint;
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
len:=ppufile.getlongint;
|
|
getmem(str,len+1);
|
|
ppufile.getdata(str^,len);
|
|
str[len]:=#0;
|
|
end;
|
|
|
|
|
|
procedure tai_comment.ppuwrite(ppufile:tcompilerppufile);
|
|
var
|
|
len : longint;
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
len:=strlen(str);
|
|
ppufile.putlongint(len);
|
|
ppufile.putdata(str^,len);
|
|
end;
|
|
|
|
|
|
function tai_comment.getcopy : tlinkedlistitem;
|
|
var
|
|
p : tlinkedlistitem;
|
|
begin
|
|
p:=inherited getcopy;
|
|
getmem(tai_comment(p).str,strlen(str)+1);
|
|
move(str^,tai_comment(p).str^,strlen(str)+1);
|
|
getcopy:=p;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_STABS
|
|
****************************************************************************}
|
|
|
|
constructor tai_stab.create(_stabtype:TStabType;_str : pchar);
|
|
begin
|
|
inherited create;
|
|
typ:=ait_stab;
|
|
str:=_str;
|
|
stabtype:=_stabtype;
|
|
end;
|
|
|
|
constructor tai_stab.create_str(_stabtype:TStabType;const s:string);
|
|
begin
|
|
self.create(_stabtype,strpnew(s));
|
|
end;
|
|
|
|
constructor tai_stab.create_ansistr(_stabtype:TStabType;const s:ansistring);
|
|
begin
|
|
inherited create;
|
|
typ:=ait_stab;
|
|
stabtype:=_stabtype;
|
|
getmem(str,length(s)+1);
|
|
move(s[1],str^,length(s)+1);
|
|
end;
|
|
|
|
destructor tai_stab.destroy;
|
|
begin
|
|
freemem(str);
|
|
inherited destroy;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_FORCE_LINE
|
|
****************************************************************************}
|
|
|
|
constructor tai_force_line.create;
|
|
begin
|
|
inherited create;
|
|
typ:=ait_force_line;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_FUNCTION_NAME
|
|
****************************************************************************}
|
|
|
|
constructor tai_function_name.create(const s:string);
|
|
begin
|
|
inherited create;
|
|
typ:=ait_function_name;
|
|
funcname:=stringdup(s);
|
|
end;
|
|
|
|
destructor tai_function_name.destroy;
|
|
begin
|
|
stringdispose(funcname);
|
|
inherited destroy;
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
TAI_CUTOBJECT
|
|
****************************************************************************}
|
|
|
|
constructor tai_cutobject.Create;
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_cutobject;
|
|
place:=cut_normal;
|
|
end;
|
|
|
|
|
|
constructor tai_cutobject.Create_begin;
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_cutobject;
|
|
place:=cut_begin;
|
|
end;
|
|
|
|
|
|
constructor tai_cutobject.Create_end;
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_cutobject;
|
|
place:=cut_end;
|
|
end;
|
|
|
|
|
|
constructor tai_cutobject.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
place:=TCutPlace(ppufile.getbyte);
|
|
end;
|
|
|
|
|
|
procedure tai_cutobject.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putbyte(byte(place));
|
|
end;
|
|
|
|
|
|
{****************************************************************************
|
|
Tai_Marker
|
|
****************************************************************************}
|
|
|
|
constructor Tai_Marker.Create(_Kind: TAsmMarker);
|
|
begin
|
|
Inherited Create;
|
|
typ := ait_marker;
|
|
Kind := _Kind;
|
|
end;
|
|
|
|
|
|
constructor Tai_Marker.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
kind:=TAsmMarker(ppufile.getbyte);
|
|
end;
|
|
|
|
|
|
procedure Tai_Marker.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putbyte(byte(kind));
|
|
end;
|
|
|
|
|
|
{*****************************************************************************
|
|
tai_tempalloc
|
|
*****************************************************************************}
|
|
|
|
constructor tai_tempalloc.alloc(pos,size:longint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_tempalloc;
|
|
allocation:=true;
|
|
temppos:=pos;
|
|
tempsize:=size;
|
|
{$ifdef EXTDEBUG}
|
|
problem:=nil;
|
|
{$endif EXTDEBUG}
|
|
end;
|
|
|
|
|
|
destructor tai_tempalloc.destroy;
|
|
begin
|
|
{$ifdef EXTDEBUG}
|
|
stringdispose(problem);
|
|
{$endif EXTDEBUG}
|
|
inherited destroy;
|
|
end;
|
|
|
|
|
|
constructor tai_tempalloc.dealloc(pos,size:longint);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_tempalloc;
|
|
allocation:=false;
|
|
temppos:=pos;
|
|
tempsize:=size;
|
|
{$ifdef EXTDEBUG}
|
|
problem:=nil;
|
|
{$endif EXTDEBUG}
|
|
end;
|
|
|
|
|
|
{$ifdef EXTDEBUG}
|
|
constructor tai_tempalloc.allocinfo(pos,size:longint;const st:string);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_tempalloc;
|
|
allocation:=false;
|
|
temppos:=pos;
|
|
tempsize:=size;
|
|
problem:=stringdup(st);
|
|
end;
|
|
{$endif EXTDEBUG}
|
|
|
|
|
|
constructor tai_tempalloc.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
temppos:=ppufile.getlongint;
|
|
tempsize:=ppufile.getlongint;
|
|
allocation:=boolean(ppufile.getbyte);
|
|
{$ifdef EXTDEBUG}
|
|
problem:=nil;
|
|
{$endif EXTDEBUG}
|
|
end;
|
|
|
|
|
|
procedure tai_tempalloc.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putlongint(temppos);
|
|
ppufile.putlongint(tempsize);
|
|
ppufile.putbyte(byte(allocation));
|
|
end;
|
|
|
|
|
|
{*****************************************************************************
|
|
tai_regalloc
|
|
*****************************************************************************}
|
|
|
|
constructor tai_regalloc.alloc(r : tregister;ainstr:tai);
|
|
begin
|
|
inherited create;
|
|
typ:=ait_regalloc;
|
|
ratype:=ra_alloc;
|
|
reg:=r;
|
|
{ ainstr must be an instruction }
|
|
if assigned(ainstr) and
|
|
(ainstr.typ<>ait_instruction) then
|
|
internalerror(200411011);
|
|
instr:=ainstr;
|
|
end;
|
|
|
|
|
|
constructor tai_regalloc.dealloc(r : tregister;ainstr:tai);
|
|
begin
|
|
inherited create;
|
|
typ:=ait_regalloc;
|
|
ratype:=ra_dealloc;
|
|
reg:=r;
|
|
{ ainstr must be an instruction }
|
|
if assigned(ainstr) and
|
|
(ainstr.typ<>ait_instruction) then
|
|
internalerror(200411012);
|
|
instr:=ainstr;
|
|
end;
|
|
|
|
|
|
constructor tai_regalloc.sync(r : tregister);
|
|
begin
|
|
inherited create;
|
|
typ:=ait_regalloc;
|
|
ratype:=ra_sync;
|
|
reg:=r;
|
|
end;
|
|
|
|
|
|
constructor tai_regalloc.resize(r : tregister);
|
|
begin
|
|
inherited create;
|
|
typ:=ait_regalloc;
|
|
ratype:=ra_resize;
|
|
reg:=r;
|
|
end;
|
|
|
|
|
|
constructor tai_regalloc.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
ppufile.getdata(reg,sizeof(Tregister));
|
|
ratype:=tregalloctype(ppufile.getbyte);
|
|
end;
|
|
|
|
|
|
procedure tai_regalloc.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putdata(reg,sizeof(Tregister));
|
|
ppufile.putbyte(byte(ratype));
|
|
end;
|
|
|
|
|
|
{*****************************************************************************
|
|
TaiInstruction
|
|
*****************************************************************************}
|
|
|
|
constructor tai_cpu_abstract.Create(op : tasmop);
|
|
|
|
begin
|
|
inherited create;
|
|
typ:=ait_instruction;
|
|
is_jmp:=false;
|
|
opcode:=op;
|
|
ops:=0;
|
|
fillchar(condition,sizeof(condition),0);
|
|
fillchar(oper,sizeof(oper),0);
|
|
end;
|
|
|
|
|
|
destructor tai_cpu_abstract.Destroy;
|
|
var
|
|
i : integer;
|
|
begin
|
|
for i:=0 to opercnt-1 do
|
|
freeop(i);
|
|
inherited destroy;
|
|
end;
|
|
|
|
|
|
{ ---------------------------------------------------------------------
|
|
Loading of operands.
|
|
---------------------------------------------------------------------}
|
|
|
|
procedure tai_cpu_abstract.allocate_oper(opers:longint);
|
|
begin
|
|
while (opers>opercnt) do
|
|
begin
|
|
new(oper[opercnt]);
|
|
fillchar(oper[opercnt]^,sizeof(toper),0);
|
|
inc(opercnt);
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.loadconst(opidx:longint;l:aint);
|
|
begin
|
|
allocate_oper(opidx+1);
|
|
with oper[opidx]^ do
|
|
begin
|
|
if typ<>top_const then
|
|
clearop(opidx);
|
|
val:=l;
|
|
typ:=top_const;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.loadsymbol(opidx:longint;s:tasmsymbol;sofs:longint);
|
|
var
|
|
r : treference;
|
|
begin
|
|
reference_reset_symbol(r,s,sofs,1);
|
|
r.refaddr:=addr_full;
|
|
loadref(opidx,r);
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.loadlocal(opidx:longint;s:pointer;sofs:longint;indexreg:tregister;scale:byte;getoffset,forceref:boolean);
|
|
begin
|
|
if not assigned(s) then
|
|
internalerror(200204251);
|
|
allocate_oper(opidx+1);
|
|
with oper[opidx]^ do
|
|
begin
|
|
if typ<>top_local then
|
|
begin
|
|
clearop(opidx);
|
|
new(localoper);
|
|
end;
|
|
with oper[opidx]^.localoper^ do
|
|
begin
|
|
localsym:=s;
|
|
localsymofs:=sofs;
|
|
localindexreg:=indexreg;
|
|
localscale:=scale;
|
|
localgetoffset:=getoffset;
|
|
localforceref:=forceref;
|
|
end;
|
|
typ:=top_local;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.loadref(opidx:longint;const r:treference);
|
|
begin
|
|
allocate_oper(opidx+1);
|
|
with oper[opidx]^ do
|
|
begin
|
|
if typ<>top_ref then
|
|
begin
|
|
clearop(opidx);
|
|
new(ref);
|
|
end;
|
|
|
|
ref^:=r;
|
|
{$ifdef x86}
|
|
{ We allow this exception for x86, since overloading this would be
|
|
too much of a a speed penalty}
|
|
if (ref^.segment<>NR_NO) and (ref^.segment<>NR_DS) then
|
|
segprefix:=ref^.segment;
|
|
{$endif}
|
|
if (cs_create_pic in current_settings.moduleswitches) and
|
|
assigned(r.symbol) and
|
|
not assigned(r.relsymbol) and
|
|
(r.refaddr=addr_no)
|
|
{$ifdef ARM}
|
|
and not(r.base=NR_R15)
|
|
{$endif ARM}
|
|
then
|
|
internalerror(200502052);
|
|
typ:=top_ref;
|
|
if assigned(add_reg_instruction_hook) then
|
|
begin
|
|
add_reg_instruction_hook(self,ref^.base);
|
|
add_reg_instruction_hook(self,ref^.index);
|
|
end;
|
|
{ mark symbol as used }
|
|
if assigned(ref^.symbol) then
|
|
ref^.symbol.increfs;
|
|
if assigned(ref^.relsymbol) then
|
|
ref^.relsymbol.increfs;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.loadreg(opidx:longint;r:tregister);
|
|
begin
|
|
allocate_oper(opidx+1);
|
|
with oper[opidx]^ do
|
|
begin
|
|
if typ<>top_reg then
|
|
clearop(opidx);
|
|
reg:=r;
|
|
typ:=top_reg;
|
|
end;
|
|
if assigned(add_reg_instruction_hook) then
|
|
add_reg_instruction_hook(self,r);
|
|
{$ifdef ARM}
|
|
{ R15 is the PC on the ARM thus moves to R15 are jumps.
|
|
Due to speed considerations we don't use a virtual overridden method here.
|
|
Because the pc/r15 isn't handled by the reg. allocator this should never cause
|
|
problems with iregs getting r15.
|
|
}
|
|
is_jmp:=(opcode=A_MOV) and (opidx=0) and (r=NR_R15);
|
|
{$endif ARM}
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.loadoper(opidx:longint;o:toper);
|
|
begin
|
|
allocate_oper(opidx+1);
|
|
clearop(opidx);
|
|
oper[opidx]^:=o;
|
|
{ copy also the reference }
|
|
with oper[opidx]^ do
|
|
begin
|
|
case typ of
|
|
top_reg:
|
|
begin
|
|
if assigned(add_reg_instruction_hook) then
|
|
add_reg_instruction_hook(self,reg);
|
|
end;
|
|
top_ref:
|
|
begin
|
|
new(ref);
|
|
ref^:=o.ref^;
|
|
if assigned(add_reg_instruction_hook) then
|
|
begin
|
|
add_reg_instruction_hook(self,ref^.base);
|
|
add_reg_instruction_hook(self,ref^.index);
|
|
end;
|
|
end;
|
|
{$ifdef ARM}
|
|
top_shifterop:
|
|
begin
|
|
new(shifterop);
|
|
shifterop^:=o.shifterop^;
|
|
if assigned(add_reg_instruction_hook) then
|
|
add_reg_instruction_hook(self,shifterop^.rs);
|
|
end;
|
|
{$endif ARM}
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure tai_cpu_abstract.clearop(opidx:longint);
|
|
begin
|
|
with oper[opidx]^ do
|
|
begin
|
|
case typ of
|
|
top_ref:
|
|
dispose(ref);
|
|
top_local:
|
|
dispose(localoper);
|
|
{$ifdef ARM}
|
|
top_shifterop:
|
|
dispose(shifterop);
|
|
top_regset:
|
|
dispose(regset);
|
|
{$endif ARM}
|
|
end;
|
|
typ:=top_none;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.freeop(opidx:longint);
|
|
begin
|
|
clearop(opidx);
|
|
dispose(oper[opidx]);
|
|
end;
|
|
|
|
|
|
{ ---------------------------------------------------------------------
|
|
Miscellaneous methods.
|
|
---------------------------------------------------------------------}
|
|
|
|
procedure tai_cpu_abstract.SetCondition(const c:TAsmCond);
|
|
begin
|
|
condition:=c;
|
|
end;
|
|
|
|
|
|
Function tai_cpu_abstract.getcopy:TLinkedListItem;
|
|
var
|
|
i : longint;
|
|
p : tai_cpu_abstract;
|
|
begin
|
|
p:=tai_cpu_abstract(inherited getcopy);
|
|
{ make a copy of the references }
|
|
p.opercnt:=0;
|
|
p.allocate_oper(ops);
|
|
for i:=0 to ops-1 do
|
|
begin
|
|
p.oper[i]^:=oper[i]^;
|
|
case oper[i]^.typ of
|
|
top_local :
|
|
begin
|
|
new(p.oper[i]^.localoper);
|
|
p.oper[i]^.localoper^:=oper[i]^.localoper^;
|
|
end;
|
|
top_ref :
|
|
begin
|
|
new(p.oper[i]^.ref);
|
|
p.oper[i]^.ref^:=oper[i]^.ref^;
|
|
end;
|
|
{$ifdef ARM}
|
|
top_shifterop:
|
|
begin
|
|
new(p.oper[i]^.shifterop);
|
|
p.oper[i]^.shifterop^:=oper[i]^.shifterop^;
|
|
end;
|
|
{$endif ARM}
|
|
end;
|
|
end;
|
|
getcopy:=p;
|
|
end;
|
|
|
|
|
|
function tai_cpu_abstract.is_same_reg_move(regtype: Tregistertype):boolean;
|
|
begin
|
|
{ When the generic RA is used this needs to be overridden, we don't use
|
|
virtual;abstract; to prevent a lot of warnings of unimplemented abstract methods
|
|
when tai_cpu is created (PFV) }
|
|
internalerror(200404091);
|
|
result:=false;
|
|
end;
|
|
|
|
|
|
function tai_cpu_abstract.spilling_get_operation_type(opnr: longint): topertype;
|
|
begin
|
|
internalerror(200404091);
|
|
result:=operand_readwrite;
|
|
end;
|
|
|
|
|
|
function tai_cpu_abstract.spilling_get_operation_type_ref(opnr: longint; reg: tregister): topertype;
|
|
begin
|
|
result := operand_read;
|
|
end;
|
|
|
|
|
|
constructor tai_cpu_abstract.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
var
|
|
i : integer;
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
{ hopefully, we don't get problems with big/litte endian here when cross compiling :/ }
|
|
ppufile.getdata(condition,sizeof(tasmcond));
|
|
allocate_oper(ppufile.getbyte);
|
|
for i:=0 to ops-1 do
|
|
ppuloadoper(ppufile,oper[i]^);
|
|
opcode:=tasmop(ppufile.getword);
|
|
{$ifdef x86}
|
|
ppufile.getdata(segprefix,sizeof(Tregister));
|
|
{$endif x86}
|
|
is_jmp:=boolean(ppufile.getbyte);
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.ppuwrite(ppufile:tcompilerppufile);
|
|
var
|
|
i : integer;
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putdata(condition,sizeof(tasmcond));
|
|
ppufile.putbyte(ops);
|
|
for i:=0 to ops-1 do
|
|
ppuwriteoper(ppufile,oper[i]^);
|
|
ppufile.putword(word(opcode));
|
|
{$ifdef x86}
|
|
ppufile.putdata(segprefix,sizeof(Tregister));
|
|
{$endif x86}
|
|
ppufile.putbyte(byte(is_jmp));
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.buildderefimpl;
|
|
var
|
|
i : integer;
|
|
begin
|
|
for i:=0 to ops-1 do
|
|
ppubuildderefimploper(oper[i]^);
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.derefimpl;
|
|
var
|
|
i : integer;
|
|
begin
|
|
for i:=0 to ops-1 do
|
|
ppuderefoper(oper[i]^);
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.resetpass1;
|
|
begin
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.resetpass2;
|
|
begin
|
|
end;
|
|
|
|
|
|
function tai_cpu_abstract.Pass1(objdata:TObjData):longint;
|
|
begin
|
|
result:=0;
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.Pass2(objdata:TObjData);
|
|
begin
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.ppuloadoper(ppufile:tcompilerppufile;var o:toper);
|
|
begin
|
|
o.typ:=toptype(ppufile.getbyte);
|
|
o.ot:=ppufile.getlongint;
|
|
case o.typ of
|
|
top_reg :
|
|
ppufile.getdata(o.reg,sizeof(Tregister));
|
|
top_ref :
|
|
begin
|
|
new(o.ref);
|
|
{$ifdef x86}
|
|
ppufile.getdata(o.ref^.segment,sizeof(Tregister));
|
|
{$endif x86}
|
|
ppufile.getdata(o.ref^.base,sizeof(Tregister));
|
|
ppufile.getdata(o.ref^.index,sizeof(Tregister));
|
|
ppufile.getdata(o.ref^.refaddr,sizeof(o.ref^.refaddr));
|
|
o.ref^.scalefactor:=ppufile.getbyte;
|
|
o.ref^.offset:=ppufile.getaint;
|
|
o.ref^.symbol:=ppufile.getasmsymbol;
|
|
o.ref^.relsymbol:=ppufile.getasmsymbol;
|
|
end;
|
|
top_const :
|
|
o.val:=ppufile.getaint;
|
|
top_local :
|
|
begin
|
|
new(o.localoper);
|
|
with o.localoper^ do
|
|
begin
|
|
ppufile.getderef(localsymderef);
|
|
localsymofs:=ppufile.getaint;
|
|
localindexreg:=tregister(ppufile.getlongint);
|
|
localscale:=ppufile.getbyte;
|
|
localgetoffset:=(ppufile.getbyte<>0);
|
|
end;
|
|
end;
|
|
else
|
|
internalerror(2007010210);
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tai_cpu_abstract.ppuwriteoper(ppufile:tcompilerppufile;const o:toper);
|
|
begin
|
|
ppufile.putbyte(byte(o.typ));
|
|
ppufile.putlongint(o.ot);
|
|
case o.typ of
|
|
top_reg :
|
|
ppufile.putdata(o.reg,sizeof(Tregister));
|
|
top_ref :
|
|
begin
|
|
{$ifdef x86}
|
|
ppufile.putdata(o.ref^.segment,sizeof(Tregister));
|
|
{$endif x86}
|
|
ppufile.putdata(o.ref^.base,sizeof(Tregister));
|
|
ppufile.putdata(o.ref^.index,sizeof(Tregister));
|
|
ppufile.putdata(o.ref^.refaddr,sizeof(o.ref^.refaddr));
|
|
ppufile.putbyte(o.ref^.scalefactor);
|
|
ppufile.putaint(o.ref^.offset);
|
|
ppufile.putasmsymbol(o.ref^.symbol);
|
|
ppufile.putasmsymbol(o.ref^.relsymbol);
|
|
end;
|
|
top_const :
|
|
ppufile.putaint(o.val);
|
|
top_local :
|
|
begin
|
|
with o.localoper^ do
|
|
begin
|
|
ppufile.putderef(localsymderef);
|
|
ppufile.putaint(localsymofs);
|
|
ppufile.putlongint(longint(localindexreg));
|
|
ppufile.putbyte(localscale);
|
|
ppufile.putbyte(byte(localgetoffset));
|
|
end;
|
|
end;
|
|
else
|
|
internalerror(2007010211);
|
|
end;
|
|
end;
|
|
|
|
{****************************************************************************
|
|
tai_align_abstract
|
|
****************************************************************************}
|
|
|
|
constructor tai_align_abstract.Create(b: byte);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_align;
|
|
{$ifdef EXTDEBUG}
|
|
if upper(classname)='TAI_ALIGN_ABSTRACT' then
|
|
internalerror(200709191);
|
|
{$endif EXTDEBUG}
|
|
if b in [1,2,4,8,16,32] then
|
|
aligntype := b
|
|
else
|
|
aligntype := 1;
|
|
fillsize:=0;
|
|
fillop:=0;
|
|
use_op:=false;
|
|
end;
|
|
|
|
|
|
constructor tai_align_abstract.Create_op(b: byte; _op: byte);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_align;
|
|
if b in [1,2,4,8,16,32] then
|
|
aligntype := b
|
|
else
|
|
aligntype := 1;
|
|
fillsize:=0;
|
|
fillop:=_op;
|
|
use_op:=true;
|
|
end;
|
|
|
|
|
|
constructor tai_align_abstract.Create_zeros(b: byte);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_align;
|
|
if b in [1,2,4,8,16,32] then
|
|
aligntype := b
|
|
else
|
|
aligntype := 1;
|
|
use_op:=true;
|
|
fillsize:=0;
|
|
fillop:=0;
|
|
end;
|
|
|
|
|
|
function tai_align_abstract.calculatefillbuf(var buf : tfillbuffer;executable : boolean):pchar;
|
|
begin
|
|
if fillsize>sizeof(buf) then
|
|
internalerror(200404293);
|
|
fillchar(buf,high(buf),fillop);
|
|
calculatefillbuf:=pchar(@buf);
|
|
end;
|
|
|
|
|
|
constructor tai_align_abstract.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t,ppufile);
|
|
aligntype:=ppufile.getbyte;
|
|
fillsize:=0;
|
|
fillop:=ppufile.getbyte;
|
|
use_op:=boolean(ppufile.getbyte);
|
|
end;
|
|
|
|
|
|
procedure tai_align_abstract.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putbyte(aligntype);
|
|
ppufile.putbyte(fillop);
|
|
ppufile.putbyte(byte(use_op));
|
|
end;
|
|
|
|
{****************************************************************************
|
|
tai_seh_directive
|
|
****************************************************************************}
|
|
|
|
const
|
|
datatypemap: array[TAsmSehDirective] of TSehDirectiveDatatype=(
|
|
sd_string, { proc }
|
|
sd_none, { endproc }
|
|
sd_none, { endprologue }
|
|
sd_string, { handler }
|
|
sd_none, { handlerdata }
|
|
sd_none,sd_none,sd_none, { eh, 32, no32 }
|
|
sd_regoffset, { setframe }
|
|
sd_offset, { stackalloc }
|
|
sd_reg, { pushreg }
|
|
sd_regoffset, { savereg }
|
|
sd_regoffset, { savexmm }
|
|
sd_none { pushframe }
|
|
);
|
|
|
|
constructor tai_seh_directive.create(_kind:TAsmSehDirective);
|
|
begin
|
|
inherited Create;
|
|
typ:=ait_seh_directive;
|
|
kind:=_kind;
|
|
data.typ:=datatypemap[_kind];
|
|
end;
|
|
|
|
constructor tai_seh_directive.create_name(_kind:TAsmSehDirective;const _name:string);
|
|
begin
|
|
create(_kind);
|
|
data.name:=stringdup(_name);
|
|
end;
|
|
|
|
constructor tai_seh_directive.create_reg(_kind:TAsmSehDirective;r:TRegister);
|
|
begin
|
|
create(_kind);
|
|
data.reg:=r;
|
|
end;
|
|
|
|
constructor tai_seh_directive.create_offset(_kind:TAsmSehDirective;ofs:dword);
|
|
begin
|
|
create(_kind);
|
|
data.offset:=ofs;
|
|
end;
|
|
|
|
constructor tai_seh_directive.create_reg_offset(_kind:TAsmSehDirective;
|
|
r:TRegister;ofs:dword);
|
|
begin
|
|
create(_kind);
|
|
data.offset:=ofs;
|
|
data.reg:=r;
|
|
end;
|
|
|
|
constructor tai_seh_directive.ppuload(t:taitype;ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuload(t, ppufile);
|
|
kind:=TAsmSehDirective(ppufile.getbyte);
|
|
data.typ:=datatypemap[kind];
|
|
case data.typ of
|
|
sd_none: ;
|
|
sd_string:
|
|
begin
|
|
data.name:=stringdup(ppufile.getstring);
|
|
data.flags:=ppufile.getbyte;
|
|
end;
|
|
|
|
sd_reg,sd_offset,sd_regoffset:
|
|
begin
|
|
ppufile.getdata(data.reg,sizeof(TRegister));
|
|
data.offset:=ppufile.getdword;
|
|
end;
|
|
else
|
|
InternalError(2011091201);
|
|
end;
|
|
end;
|
|
|
|
destructor tai_seh_directive.destroy;
|
|
begin
|
|
if data.typ=sd_string then
|
|
stringdispose(data.name);
|
|
inherited destroy;
|
|
end;
|
|
|
|
procedure tai_seh_directive.ppuwrite(ppufile:tcompilerppufile);
|
|
begin
|
|
inherited ppuwrite(ppufile);
|
|
ppufile.putbyte(ord(kind));
|
|
case data.typ of
|
|
sd_none: ;
|
|
sd_string:
|
|
begin
|
|
ppufile.putstring(data.name^);
|
|
ppufile.putbyte(data.flags);
|
|
end;
|
|
|
|
sd_reg,sd_offset,sd_regoffset:
|
|
begin
|
|
ppufile.putdata(data.reg,sizeof(TRegister));
|
|
ppufile.putdword(data.offset);
|
|
end;
|
|
else
|
|
InternalError(2011091202);
|
|
end;
|
|
end;
|
|
|
|
procedure tai_seh_directive.generate_code(objdata:TObjData);
|
|
begin
|
|
end;
|
|
|
|
begin
|
|
{$push}{$warnings off}
|
|
{ taitype should fit into a 4 byte set for speed reasons }
|
|
if ord(high(taitype))>31 then
|
|
internalerror(201108181);
|
|
{$pop}
|
|
end.
|