hlcg2ll.pas 63 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539
  1. {
  2. Copyright (c) 1998-2010 by Florian Klaempfl and Jonas Maebe
  3. Member of the Free Pascal development team
  4. This unit implements the high level code generator object for targets that
  5. only use the low-level code generator
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with this program; if not, write to the Free Software
  16. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17. ****************************************************************************
  18. }
  19. {# @abstract(High level code generator to low level)
  20. This class passes the high level code generator methods through to the
  21. low level code generator.
  22. }
  23. unit hlcg2ll;
  24. {$i fpcdefs.inc}
  25. { define hlcginline}
  26. interface
  27. uses
  28. cclasses,globtype,constexp,
  29. cpubase,cgbase,cgutils,parabase,
  30. aasmbase,aasmtai,aasmdata,aasmcpu,
  31. symconst,symtype,symdef,rgobj,
  32. node,hlcgobj
  33. ;
  34. type
  35. {# @abstract(Abstract high level code generator)
  36. This class implements an abstract instruction generator. All
  37. methods of this class are generic and are mapped to low level code
  38. generator methods by default. They have to be overridden for higher
  39. level targets
  40. }
  41. { thlcg2ll }
  42. thlcg2ll = class(thlcgobj)
  43. public
  44. {************************************************}
  45. { basic routines }
  46. constructor create;
  47. procedure init_register_allocators;override;
  48. {# Clean up the register allocators needed for the codegenerator.}
  49. procedure done_register_allocators;override;
  50. {# Set whether live_start or live_end should be updated when allocating registers, needed when e.g. generating initcode after the rest of the code. }
  51. procedure set_regalloc_live_range_direction(dir: TRADirection);override;
  52. {# Gets a register suitable to do integer operations on.}
  53. function getintregister(list:TAsmList;size:tdef):Tregister;override;
  54. {# Gets a register suitable to do integer operations on.}
  55. function getaddressregister(list:TAsmList;size:tdef):Tregister;override;
  56. function getfpuregister(list:TAsmList;size:tdef):Tregister;override;
  57. { warning: only works correctly for fpu types currently }
  58. function getmmregister(list:TAsmList;size:tdef):Tregister;override;
  59. function getflagregister(list:TAsmList;size:tdef):Tregister;override;
  60. {Does the generic cg need SIMD registers, like getmmxregister? Or should
  61. the cpu specific child cg object have such a method?}
  62. function uses_registers(rt:Tregistertype):boolean; inline;
  63. procedure do_register_allocation(list:TAsmList;headertai:tai); inline;
  64. procedure translate_register(var reg : tregister); inline;
  65. {# Allocates register r by inserting a pai_realloc record }
  66. procedure a_reg_alloc(list : TAsmList;r : tregister); inline;
  67. {# Deallocates register r by inserting a pa_regdealloc record}
  68. procedure a_reg_dealloc(list : TAsmList;r : tregister); inline;
  69. { Synchronize register, make sure it is still valid }
  70. procedure a_reg_sync(list : TAsmList;r : tregister); inline;
  71. {# Pass a parameter, which is located in a register, to a routine.
  72. This routine should push/send the parameter to the routine, as
  73. required by the specific processor ABI and routine modifiers.
  74. It must generate register allocation information for the cgpara in
  75. case it consists of cpuregisters.
  76. @param(size size of the operand in the register)
  77. @param(r register source of the operand)
  78. @param(cgpara where the parameter will be stored)
  79. }
  80. procedure a_load_reg_cgpara(list : TAsmList;size : tdef;r : tregister;const cgpara : TCGPara);override;
  81. {# Pass a parameter, which is a constant, to a routine.
  82. A generic version is provided. This routine should
  83. be overridden for optimization purposes if the cpu
  84. permits directly sending this type of parameter.
  85. It must generate register allocation information for the cgpara in
  86. case it consists of cpuregisters.
  87. @param(size size of the operand in constant)
  88. @param(a value of constant to send)
  89. @param(cgpara where the parameter will be stored)
  90. }
  91. procedure a_load_const_cgpara(list : TAsmList;tosize : tdef;a : tcgint;const cgpara : TCGPara);override;
  92. {# Pass the value of a parameter, which is located in memory, to a routine.
  93. A generic version is provided. This routine should
  94. be overridden for optimization purposes if the cpu
  95. permits directly sending this type of parameter.
  96. It must generate register allocation information for the cgpara in
  97. case it consists of cpuregisters.
  98. @param(size size of the operand in constant)
  99. @param(r Memory reference of value to send)
  100. @param(cgpara where the parameter will be stored)
  101. }
  102. procedure a_load_ref_cgpara(list : TAsmList;size : tdef;const r : treference;const cgpara : TCGPara);override;
  103. {# Pass the value of a parameter, which can be located either in a register or memory location,
  104. to a routine.
  105. A generic version is provided.
  106. @param(l location of the operand to send)
  107. @param(nr parameter number (starting from one) of routine (from left to right))
  108. @param(cgpara where the parameter will be stored)
  109. }
  110. procedure a_load_loc_cgpara(list : TAsmList;size : tdef; const l : tlocation;const cgpara : TCGPara);override;
  111. {# Pass the address of a reference to a routine. This routine
  112. will calculate the address of the reference, and pass this
  113. calculated address as a parameter.
  114. It must generate register allocation information for the cgpara in
  115. case it consists of cpuregisters.
  116. A generic version is provided. This routine should
  117. be overridden for optimization purposes if the cpu
  118. permits directly sending this type of parameter.
  119. @param(fromsize type of the reference we are taking the address of)
  120. @param(tosize type of the pointer that we get as a result)
  121. @param(r reference to get address from)
  122. }
  123. procedure a_loadaddr_ref_cgpara(list : TAsmList;fromsize : tdef;const r : treference;const cgpara : TCGPara);override;
  124. function a_call_name(list : TAsmList;pd : tprocdef;const s : TSymStr; forceresdef: tdef; weak: boolean): tcgpara;override;
  125. procedure a_call_reg(list : TAsmList;pd : tabstractprocdef;reg : tregister);override;
  126. { same as a_call_name, might be overridden on certain architectures to emit
  127. static calls without usage of a got trampoline }
  128. function a_call_name_static(list : TAsmList;pd : tprocdef;const s : TSymStr; forceresdef: tdef): tcgpara;override;
  129. { move instructions }
  130. procedure a_load_const_reg(list : TAsmList;tosize : tdef;a : tcgint;register : tregister);override;
  131. procedure a_load_const_ref(list : TAsmList;tosize : tdef;a : tcgint;const ref : treference);override;
  132. procedure a_load_const_loc(list : TAsmList;tosize : tdef;a : tcgint;const loc : tlocation);override;
  133. procedure a_load_reg_ref(list : TAsmList;fromsize, tosize : tdef;register : tregister;const ref : treference);override;
  134. procedure a_load_reg_ref_unaligned(list : TAsmList;fromsize, tosize : tdef;register : tregister;const ref : treference);override;
  135. procedure a_load_reg_reg(list : TAsmList;fromsize, tosize : tdef;reg1,reg2 : tregister);override;
  136. procedure a_load_reg_loc(list : TAsmList;fromsize, tosize : tdef;reg : tregister;const loc: tlocation);override;
  137. procedure a_load_ref_reg(list : TAsmList;fromsize, tosize : tdef;const ref : treference;register : tregister);override;
  138. procedure a_load_ref_reg_unaligned(list : TAsmList;fromsize, tosize : tdef;const ref : treference;register : tregister);override;
  139. procedure a_load_ref_ref(list : TAsmList;fromsize, tosize : tdef;const sref : treference;const dref : treference);override;
  140. procedure a_load_loc_reg(list : TAsmList;fromsize, tosize : tdef; const loc: tlocation; reg : tregister);override;
  141. procedure a_load_loc_ref(list : TAsmList;fromsize, tosize: tdef; const loc: tlocation; const ref : treference);override;
  142. procedure a_loadaddr_ref_reg(list : TAsmList;fromsize, tosize : tdef;const ref : treference;r : tregister);override;
  143. { bit scan instructions }
  144. procedure a_bit_scan_reg_reg(list: TAsmList; reverse: boolean; size: tdef; src, dst: tregister); override;
  145. { fpu move instructions }
  146. procedure a_loadfpu_reg_reg(list: TAsmList; fromsize, tosize: tdef; reg1, reg2: tregister); override;
  147. procedure a_loadfpu_ref_reg(list: TAsmList; fromsize, tosize: tdef; const ref: treference; reg: tregister); override;
  148. procedure a_loadfpu_reg_ref(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const ref: treference); override;
  149. procedure a_loadfpu_ref_ref(list: TAsmList; fromsize, tosize: tdef; const ref1,ref2: treference);override;
  150. procedure a_loadfpu_loc_reg(list: TAsmList; fromsize, tosize: tdef; const loc: tlocation; const reg: tregister);override;
  151. procedure a_loadfpu_reg_loc(list: TAsmList; fromsize, tosize: tdef; const reg: tregister; const loc: tlocation);override;
  152. procedure a_loadfpu_reg_cgpara(list : TAsmList;fromsize: tdef;const r : tregister;const cgpara : TCGPara);override;
  153. procedure a_loadfpu_ref_cgpara(list : TAsmList;fromsize : tdef;const ref : treference;const cgpara : TCGPara);override;
  154. { vector register move instructions }
  155. procedure a_loadmm_reg_reg(list: TAsmList; fromsize, tosize: tdef;reg1, reg2: tregister;shuffle : pmmshuffle); override;
  156. procedure a_loadmm_ref_reg(list: TAsmList; fromsize, tosize: tdef;const ref: treference; reg: tregister;shuffle : pmmshuffle); override;
  157. procedure a_loadmm_reg_ref(list: TAsmList; fromsize, tosize: tdef;reg: tregister; const ref: treference;shuffle : pmmshuffle); override;
  158. procedure a_loadmm_loc_reg(list: TAsmList; fromsize, tosize: tdef; const loc: tlocation; const reg: tregister;shuffle : pmmshuffle);override;
  159. procedure a_loadmm_reg_loc(list: TAsmList; fromsize, tosize: tdef; const reg: tregister; const loc: tlocation;shuffle : pmmshuffle);override;
  160. procedure a_loadmm_reg_cgpara(list: TAsmList; fromsize: tdef; reg: tregister;const cgpara : TCGPara;shuffle : pmmshuffle); override;
  161. procedure a_loadmm_ref_cgpara(list: TAsmList; fromsize: tdef; const ref: treference;const cgpara : TCGPara;shuffle : pmmshuffle); override;
  162. procedure a_loadmm_loc_cgpara(list: TAsmList; fromsize: tdef; const loc: tlocation; const cgpara : TCGPara;shuffle : pmmshuffle); override;
  163. procedure a_opmm_reg_reg(list: TAsmList; Op: TOpCG; size : tdef;src,dst: tregister;shuffle : pmmshuffle); override;
  164. procedure a_opmm_ref_reg(list: TAsmList; Op: TOpCG; size : tdef;const ref: treference; reg: tregister;shuffle : pmmshuffle); override;
  165. procedure a_opmm_loc_reg(list: TAsmList; Op: TOpCG; size : tdef;const loc: tlocation; reg: tregister;shuffle : pmmshuffle); override;
  166. procedure a_opmm_reg_ref(list: TAsmList; Op: TOpCG; size : tdef;reg: tregister;const ref: treference; shuffle : pmmshuffle); override;
  167. procedure a_loadmm_intreg_reg(list: TAsmList; fromsize, tosize : tdef; intreg, mmreg: tregister; shuffle: pmmshuffle); override;
  168. procedure a_loadmm_reg_intreg(list: TAsmList; fromsize, tosize : tdef; mmreg, intreg: tregister; shuffle : pmmshuffle); override;
  169. { basic arithmetic operations }
  170. { note: for operators which require only one argument (not, neg), use }
  171. { the op_reg_reg, op_reg_ref or op_reg_loc methods and keep in mind }
  172. { that in this case the *second* operand is used as both source and }
  173. { destination (JM) }
  174. procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: tdef; a: tcgint; reg: TRegister); override;
  175. procedure a_op_const_ref(list : TAsmList; Op: TOpCG; size: tdef; a: tcgint; const ref: TReference); override;
  176. procedure a_op_const_loc(list : TAsmList; Op: TOpCG; size: tdef; a: tcgint; const loc: tlocation);override;
  177. procedure a_op_reg_reg(list : TAsmList; Op: TOpCG; size: tdef; reg1, reg2: TRegister); override;
  178. procedure a_op_reg_ref(list : TAsmList; Op: TOpCG; size: tdef; reg: TRegister; const ref: TReference); override;
  179. procedure a_op_ref_reg(list : TAsmList; Op: TOpCG; size: tdef; const ref: TReference; reg: TRegister); override;
  180. procedure a_op_reg_loc(list : TAsmList; Op: TOpCG; size: tdef; reg: tregister; const loc: tlocation);override;
  181. procedure a_op_ref_loc(list : TAsmList; Op: TOpCG; size: tdef; const ref: TReference; const loc: tlocation);override;
  182. { trinary operations for processors that support them, 'emulated' }
  183. { on others. None with "ref" arguments since I don't think there }
  184. { are any processors that support it (JM) }
  185. procedure a_op_const_reg_reg(list: TAsmList; op: TOpCg; size: tdef; a: tcgint; src, dst: tregister); override;
  186. procedure a_op_reg_reg_reg(list: TAsmList; op: TOpCg; size: tdef; src1, src2, dst: tregister); override;
  187. procedure a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tdef; a: tcgint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); override;
  188. procedure a_op_reg_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tdef; src1, src2, dst: tregister;setflags : boolean;var ovloc : tlocation); override;
  189. { comparison operations }
  190. procedure a_cmp_const_reg_label(list : TAsmList;size : tdef;cmp_op : topcmp;a : tcgint;reg : tregister;
  191. l : tasmlabel);override;
  192. procedure a_cmp_const_ref_label(list : TAsmList;size : tdef;cmp_op : topcmp;a : tcgint;const ref : treference;
  193. l : tasmlabel); override;
  194. procedure a_cmp_const_loc_label(list: TAsmList; size: tdef;cmp_op: topcmp; a: tcgint; const loc: tlocation;
  195. l : tasmlabel);override;
  196. procedure a_cmp_reg_reg_label(list : TAsmList;size : tdef;cmp_op : topcmp;reg1,reg2 : tregister;l : tasmlabel); override;
  197. procedure a_cmp_ref_reg_label(list : TAsmList;size : tdef;cmp_op : topcmp; const ref: treference; reg : tregister; l : tasmlabel); override;
  198. procedure a_cmp_reg_ref_label(list : TAsmList;size : tdef;cmp_op : topcmp;reg : tregister; const ref: treference; l : tasmlabel); override;
  199. procedure a_cmp_loc_reg_label(list : TAsmList;size : tdef;cmp_op : topcmp; const loc: tlocation; reg : tregister; l : tasmlabel);override;
  200. procedure a_cmp_ref_loc_label(list: TAsmList; size: tdef;cmp_op: topcmp; const ref: treference; const loc: tlocation; l : tasmlabel);override;
  201. procedure a_jmp_always(list : TAsmList;l: tasmlabel); override;
  202. {$ifdef cpuflags}
  203. procedure a_jmp_flags(list : TAsmList;const f : TResFlags;l: tasmlabel); override;
  204. {# Depending on the value to check in the flags, either sets the register reg to one (if the flag is set)
  205. or zero (if the flag is cleared). The size parameter indicates the destination size register.
  206. }
  207. procedure g_flags2reg(list: TAsmList; size: tdef; const f: tresflags; reg: TRegister); override;
  208. procedure g_flags2ref(list: TAsmList; size: tdef; const f: tresflags; const ref:TReference); override;
  209. {$endif cpuflags}
  210. // procedure g_maybe_testvmt(list : TAsmList;reg:tregister;objdef:tobjectdef);
  211. {# This should emit the opcode to copy len bytes from the source
  212. to destination.
  213. It must be overridden for each new target processor.
  214. @param(source Source reference of copy)
  215. @param(dest Destination reference of copy)
  216. }
  217. procedure g_concatcopy(list : TAsmList;size: tdef; const source,dest : treference);override;
  218. {# This should emit the opcode to copy len bytes from the an unaligned source
  219. to destination.
  220. It must be overridden for each new target processor.
  221. @param(source Source reference of copy)
  222. @param(dest Destination reference of copy)
  223. }
  224. procedure g_concatcopy_unaligned(list : TAsmList;size: tdef; const source,dest : treference);override;
  225. {# Generates overflow checking code for a node }
  226. procedure g_overflowcheck(list: TAsmList; const Loc:tlocation; def:tdef); override;
  227. procedure g_overflowCheck_loc(List:TAsmList;const Loc:TLocation;def:TDef;var ovloc : tlocation);override;
  228. {# Emits instructions when compilation is done in profile
  229. mode (this is set as a command line option). The default
  230. behavior does nothing, should be overridden as required.
  231. }
  232. procedure g_profilecode(list : TAsmList);override;
  233. {# Emits instruction for allocating @var(size) bytes at the stackpointer
  234. @param(size Number of bytes to allocate)
  235. }
  236. procedure g_stackpointer_alloc(list : TAsmList;size : longint);override;
  237. {# Emits instruction for allocating the locals in entry
  238. code of a routine. This is one of the first
  239. routine called in @var(genentrycode).
  240. @param(localsize Number of bytes to allocate as locals)
  241. }
  242. procedure g_proc_entry(list : TAsmList;localsize : longint;nostackframe:boolean);override;
  243. {# Emits instructions for returning from a subroutine.
  244. Should also restore the framepointer and stack.
  245. @param(parasize Number of bytes of parameters to deallocate from stack)
  246. }
  247. procedure g_proc_exit(list : TAsmList;parasize:longint;nostackframe:boolean);override;
  248. procedure g_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint);override;
  249. procedure g_adjust_self_value(list:TAsmList;procdef: tprocdef;ioffset: aint);override;
  250. { generate a stub which only purpose is to pass control the given external method,
  251. setting up any additional environment before doing so (if required).
  252. The default implementation issues a jump instruction to the external name. }
  253. // procedure g_external_wrapper(list : TAsmList; procdef: tprocdef; const externalname: string); override;
  254. { Generate code to exit an unwind-protected region. The default implementation
  255. produces a simple jump to destination label. }
  256. procedure g_local_unwind(list: TAsmList; l: TAsmLabel);override;
  257. procedure location_force_reg(list:TAsmList;var l:tlocation;src_size,dst_size:tdef;maybeconst:boolean);override;
  258. procedure location_force_mem(list:TAsmList;var l:tlocation;size:tdef);override;
  259. procedure location_force_mmregscalar(list:TAsmList;var l: tlocation;size:tdef;maybeconst:boolean);override;
  260. // procedure location_force_mmreg(list:TAsmList;var l: tlocation;size:tdef;maybeconst:boolean);override;
  261. procedure maketojumpbool(list:TAsmList; p : tnode);override;
  262. procedure gen_load_para_value(list:TAsmList);override;
  263. protected
  264. procedure gen_loadfpu_loc_cgpara(list: TAsmList; size: tdef; const l: tlocation;const cgpara: tcgpara;locintsize: longint);override;
  265. public
  266. procedure gen_load_loc_cgpara(list: TAsmList; vardef: tdef; const l: tlocation; const cgpara: tcgpara); override;
  267. procedure gen_load_cgpara_loc(list: TAsmList; vardef: tdef; const para: TCGPara; var destloc: tlocation; reusepara: boolean); override;
  268. protected
  269. { returns the equivalent MM size for a vector register that contains
  270. a record, because in that case "size" will contain a cgsize
  271. representing an integer size}
  272. function getintmmcgsize(reg: tregister; size: tcgsize): tcgsize; virtual;
  273. end;
  274. implementation
  275. uses
  276. globals,options,systems,
  277. verbose,defutil,paramgr,symsym,
  278. cgobj,tgobj,cutils,procinfo,
  279. ncgutil;
  280. { thlcg2ll }
  281. constructor thlcg2ll.create;
  282. begin
  283. end;
  284. procedure thlcg2ll.init_register_allocators;
  285. begin
  286. cg.init_register_allocators;
  287. end;
  288. procedure thlcg2ll.done_register_allocators;
  289. begin
  290. cg.done_register_allocators;
  291. end;
  292. procedure thlcg2ll.set_regalloc_live_range_direction(dir: TRADirection);
  293. begin
  294. cg.set_regalloc_live_range_direction(dir);
  295. end;
  296. function thlcg2ll.getintregister(list: TAsmList; size: tdef): Tregister;
  297. begin
  298. result:=cg.getintregister(list,def_cgsize(size));
  299. end;
  300. function thlcg2ll.getaddressregister(list: TAsmList; size: tdef): Tregister;
  301. begin
  302. result:=cg.getaddressregister(list);
  303. end;
  304. function thlcg2ll.getfpuregister(list: TAsmList; size: tdef): Tregister;
  305. begin
  306. result:=cg.getfpuregister(list,def_cgsize(size));
  307. end;
  308. function thlcg2ll.getmmregister(list: TAsmList; size: tdef): Tregister;
  309. begin
  310. result:=cg.getmmregister(list,def_cgsize(size));
  311. end;
  312. (*
  313. function thlcg2ll.getmmregister(list: TAsmList; size: tdef): Tregister;
  314. begin
  315. result:=cg.getmmregister(list,def_cgsize(size));
  316. end;
  317. *)
  318. function thlcg2ll.getflagregister(list: TAsmList; size: tdef): Tregister;
  319. begin
  320. result:=cg.getflagregister(list,def_cgsize(size));
  321. end;
  322. function thlcg2ll.uses_registers(rt: Tregistertype): boolean;
  323. begin
  324. result:=cg.uses_registers(rt);
  325. end;
  326. procedure thlcg2ll.do_register_allocation(list: TAsmList; headertai: tai);
  327. begin
  328. cg.do_register_allocation(list,headertai);
  329. end;
  330. procedure thlcg2ll.translate_register(var reg: tregister);
  331. begin
  332. cg.translate_register(reg);
  333. end;
  334. procedure thlcg2ll.a_reg_alloc(list: TAsmList; r: tregister);
  335. begin
  336. cg.a_reg_alloc(list,r);
  337. end;
  338. procedure thlcg2ll.a_reg_dealloc(list: TAsmList; r: tregister);
  339. begin
  340. cg.a_reg_dealloc(list,r);
  341. end;
  342. procedure thlcg2ll.a_reg_sync(list: TAsmList; r: tregister);
  343. begin
  344. cg.a_reg_sync(list,r);
  345. end;
  346. procedure thlcg2ll.a_load_reg_cgpara(list: TAsmList; size: tdef; r: tregister; const cgpara: TCGPara);
  347. begin
  348. cg.a_load_reg_cgpara(list,def_cgsize(size),r,cgpara);
  349. end;
  350. procedure thlcg2ll.a_load_const_cgpara(list: TAsmList; tosize: tdef; a: tcgint; const cgpara: TCGPara);
  351. begin
  352. cg.a_load_const_cgpara(list,def_cgsize(tosize),a,cgpara);
  353. end;
  354. procedure thlcg2ll.a_load_ref_cgpara(list: TAsmList; size: tdef; const r: treference; const cgpara: TCGPara);
  355. begin
  356. cg.a_load_ref_cgpara(list,def_cgsize(size),r,cgpara);
  357. end;
  358. procedure thlcg2ll.a_load_loc_cgpara(list: TAsmList; size: tdef; const l: tlocation; const cgpara: TCGPara);
  359. begin
  360. cg.a_load_loc_cgpara(list,l,cgpara);
  361. end;
  362. procedure thlcg2ll.a_loadaddr_ref_cgpara(list: TAsmList; fromsize: tdef; const r: treference; const cgpara: TCGPara);
  363. begin
  364. cg.a_loadaddr_ref_cgpara(list,r,cgpara);
  365. end;
  366. function thlcg2ll.a_call_name(list: TAsmList; pd: tprocdef; const s: TSymStr; forceresdef: tdef; weak: boolean): tcgpara;
  367. begin
  368. cg.a_call_name(list,s,weak);
  369. result:=get_call_result_cgpara(pd,forceresdef);
  370. end;
  371. procedure thlcg2ll.a_call_reg(list: TAsmList; pd: tabstractprocdef; reg: tregister);
  372. begin
  373. cg.a_call_reg(list,reg);
  374. end;
  375. function thlcg2ll.a_call_name_static(list: TAsmList; pd: tprocdef; const s: TSymStr; forceresdef: tdef): tcgpara;
  376. begin
  377. cg.a_call_name_static(list,s);
  378. result:=get_call_result_cgpara(pd,forceresdef);
  379. end;
  380. procedure thlcg2ll.a_load_const_reg(list: TAsmList; tosize: tdef; a: tcgint; register: tregister);
  381. begin
  382. cg.a_load_const_reg(list,def_cgsize(tosize),a,register);
  383. end;
  384. procedure thlcg2ll.a_load_const_ref(list: TAsmList; tosize: tdef; a: tcgint; const ref: treference);
  385. begin
  386. cg.a_load_const_ref(list,def_cgsize(tosize),a,ref);
  387. end;
  388. procedure thlcg2ll.a_load_const_loc(list: TAsmList; tosize: tdef; a: tcgint; const loc: tlocation);
  389. begin
  390. case loc.loc of
  391. LOC_SUBSETREG,LOC_CSUBSETREG,
  392. LOC_SUBSETREF,LOC_CSUBSETREF:
  393. inherited
  394. else
  395. cg.a_load_const_loc(list,a,loc);
  396. end;
  397. end;
  398. procedure thlcg2ll.a_load_reg_ref(list: TAsmList; fromsize, tosize: tdef; register: tregister; const ref: treference);
  399. begin
  400. cg.a_load_reg_ref(list,def_cgsize(fromsize),def_cgsize(tosize),register,ref);
  401. end;
  402. procedure thlcg2ll.a_load_reg_ref_unaligned(list: TAsmList; fromsize, tosize: tdef; register: tregister; const ref: treference);
  403. begin
  404. cg.a_load_reg_ref_unaligned(list,def_cgsize(fromsize),def_cgsize(tosize),register,ref);
  405. end;
  406. procedure thlcg2ll.a_load_reg_reg(list: TAsmList; fromsize, tosize: tdef; reg1, reg2: tregister);
  407. begin
  408. cg.a_load_reg_reg(list,def_cgsize(fromsize),def_cgsize(tosize),reg1,reg2);
  409. end;
  410. procedure thlcg2ll.a_load_reg_loc(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const loc: tlocation);
  411. var
  412. fromcgsize: tcgsize;
  413. begin
  414. case loc.loc of
  415. LOC_SUBSETREG,LOC_CSUBSETREG,
  416. LOC_SUBSETREF,LOC_CSUBSETREF:
  417. inherited;
  418. else
  419. begin
  420. { avoid problems with 3-byte records and the like }
  421. if (fromsize.typ<>floatdef) and
  422. (fromsize=tosize) then
  423. fromcgsize:=loc.size
  424. else
  425. { fromsize can be a floatdef (in case the destination is an
  426. MMREGISTER) -> use int_cgsize rather than def_cgsize to get the
  427. corresponding integer cgsize of the def }
  428. fromcgsize:=int_cgsize(fromsize.size);
  429. cg.a_load_reg_loc(list,fromcgsize,reg,loc);
  430. end;
  431. end;
  432. end;
  433. procedure thlcg2ll.a_load_ref_reg(list: TAsmList; fromsize, tosize: tdef; const ref: treference; register: tregister);
  434. begin
  435. cg.a_load_ref_reg(list,def_cgsize(fromsize),def_cgsize(tosize),ref,register);
  436. end;
  437. procedure thlcg2ll.a_load_ref_reg_unaligned(list: TAsmList; fromsize, tosize: tdef; const ref: treference; register: tregister);
  438. begin
  439. cg.a_load_ref_reg_unaligned(list,def_cgsize(fromsize),def_cgsize(tosize),ref,register);
  440. end;
  441. procedure thlcg2ll.a_load_ref_ref(list: TAsmList; fromsize, tosize: tdef; const sref: treference; const dref: treference);
  442. begin
  443. cg.a_load_ref_ref(list,def_cgsize(fromsize),def_cgsize(tosize),sref,dref);
  444. end;
  445. procedure thlcg2ll.a_load_loc_reg(list: TAsmList; fromsize, tosize: tdef; const loc: tlocation; reg: tregister);
  446. var
  447. tocgsize: tcgsize;
  448. begin
  449. case loc.loc of
  450. LOC_SUBSETREG,LOC_CSUBSETREG,
  451. LOC_SUBSETREF,LOC_CSUBSETREF:
  452. inherited
  453. else
  454. begin
  455. { avoid problems with 3-byte records and the like }
  456. if fromsize=tosize then
  457. tocgsize:=loc.size
  458. else
  459. tocgsize:=def_cgsize(tosize);
  460. cg.a_load_loc_reg(list,tocgsize,loc,reg);
  461. end;
  462. end;
  463. end;
  464. procedure thlcg2ll.a_load_loc_ref(list: TAsmList; fromsize, tosize: tdef; const loc: tlocation; const ref: treference);
  465. var
  466. tocgsize: tcgsize;
  467. begin
  468. case loc.loc of
  469. LOC_SUBSETREG,LOC_CSUBSETREG,
  470. LOC_SUBSETREF,LOC_CSUBSETREF:
  471. inherited
  472. else
  473. begin
  474. { avoid problems with 3-byte records and the like }
  475. if fromsize=tosize then
  476. tocgsize:=loc.size
  477. else
  478. tocgsize:=def_cgsize(tosize);
  479. cg.a_load_loc_ref(list,tocgsize,loc,ref);
  480. end;
  481. end;
  482. end;
  483. procedure thlcg2ll.a_loadaddr_ref_reg(list: TAsmList; fromsize, tosize: tdef; const ref: treference; r: tregister);
  484. begin
  485. cg.a_loadaddr_ref_reg(list,ref,r);
  486. end;
  487. procedure thlcg2ll.a_bit_scan_reg_reg(list: TAsmList; reverse: boolean; size: tdef; src, dst: tregister);
  488. begin
  489. cg.a_bit_scan_reg_reg(list,reverse,def_cgsize(size),src,dst);
  490. end;
  491. procedure thlcg2ll.a_loadfpu_reg_reg(list: TAsmList; fromsize, tosize: tdef; reg1, reg2: tregister);
  492. begin
  493. cg.a_loadfpu_reg_reg(list,def_cgsize(fromsize),def_cgsize(tosize),reg1,reg2);
  494. end;
  495. procedure thlcg2ll.a_loadfpu_ref_reg(list: TAsmList; fromsize, tosize: tdef; const ref: treference; reg: tregister);
  496. begin
  497. cg.a_loadfpu_ref_reg(list,def_cgsize(fromsize),def_cgsize(tosize),ref,reg);
  498. end;
  499. procedure thlcg2ll.a_loadfpu_reg_ref(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const ref: treference);
  500. begin
  501. cg.a_loadfpu_reg_ref(list,def_cgsize(fromsize),def_cgsize(tosize),reg,ref);
  502. end;
  503. procedure thlcg2ll.a_loadfpu_ref_ref(list: TAsmList; fromsize, tosize: tdef; const ref1, ref2: treference);
  504. begin
  505. cg.a_loadfpu_ref_ref(list,def_cgsize(fromsize),def_cgsize(tosize),ref1,ref2);
  506. end;
  507. procedure thlcg2ll.a_loadfpu_loc_reg(list: TAsmList; fromsize, tosize: tdef; const loc: tlocation; const reg: tregister);
  508. begin
  509. {$ifdef extdebug}
  510. if def_cgsize(fromsize)<>loc.size then
  511. internalerror(2010112102);
  512. {$endif}
  513. cg.a_loadfpu_loc_reg(list,def_cgsize(tosize),loc,reg);
  514. end;
  515. procedure thlcg2ll.a_loadfpu_reg_loc(list: TAsmList; fromsize, tosize: tdef; const reg: tregister; const loc: tlocation);
  516. var
  517. usesize: tcgsize;
  518. begin
  519. {$ifdef extdebug}
  520. if def_cgsize(tosize)<>loc.size then
  521. internalerror(2010112101);
  522. {$endif}
  523. { on some platforms, certain records are passed/returned in floating point
  524. registers -> def_cgsize() won't give us the result we need -> translate
  525. to corresponding fpu size }
  526. usesize:=def_cgsize(fromsize);
  527. if not(usesize in [OS_F32..OS_F128]) then
  528. usesize:=int_float_cgsize(tcgsize2size[usesize]);
  529. cg.a_loadfpu_reg_loc(list,usesize,reg,loc);
  530. end;
  531. procedure thlcg2ll.a_loadfpu_reg_cgpara(list: TAsmList; fromsize: tdef; const r: tregister; const cgpara: TCGPara);
  532. begin
  533. cg.a_loadfpu_reg_cgpara(list,def_cgsize(fromsize),r,cgpara);
  534. end;
  535. procedure thlcg2ll.a_loadfpu_ref_cgpara(list: TAsmList; fromsize: tdef; const ref: treference; const cgpara: TCGPara);
  536. begin
  537. cg.a_loadfpu_ref_cgpara(list,def_cgsize(fromsize),ref,cgpara);
  538. end;
  539. procedure thlcg2ll.a_loadmm_loc_reg(list: TAsmList; fromsize, tosize: tdef; const loc: tlocation; const reg: tregister;shuffle : pmmshuffle);
  540. var
  541. tmpreg: tregister;
  542. tocgsize: tcgsize;
  543. begin
  544. if def_cgmmsize(fromsize)<>loc.size then
  545. internalerror(2012071226);
  546. tocgsize:=getintmmcgsize(reg,def_cgmmsize(tosize));
  547. case loc.loc of
  548. LOC_SUBSETREG,LOC_CSUBSETREG,
  549. LOC_SUBSETREF,LOC_CSUBSETREF:
  550. begin
  551. tmpreg:=cg.getintregister(list,loc.size);
  552. a_load_loc_reg(list,fromsize,fromsize,loc,tmpreg);
  553. { integer register -> no def_cgmmsize but plain }
  554. cg.a_loadmm_intreg_reg(list,def_cgsize(fromsize),tocgsize,tmpreg,reg,shuffle);
  555. end
  556. else
  557. cg.a_loadmm_loc_reg(list,tocgsize,loc,reg,shuffle);
  558. end;
  559. end;
  560. procedure thlcg2ll.a_loadmm_reg_reg(list: TAsmList; fromsize, tosize: tdef; reg1, reg2: tregister; shuffle: pmmshuffle);
  561. var
  562. fromcgsize: tcgsize;
  563. tocgsize: tcgsize;
  564. begin
  565. fromcgsize:=getintmmcgsize(reg1,def_cgmmsize(fromsize));
  566. tocgsize:=getintmmcgsize(reg2,def_cgmmsize(tosize));
  567. { records may be stored in mmregisters, but def_cgsize will return an
  568. integer size for them... }
  569. cg.a_loadmm_reg_reg(list,fromcgsize,tocgsize,reg1,reg2,shuffle);
  570. end;
  571. procedure thlcg2ll.a_loadmm_ref_reg(list: TAsmList; fromsize, tosize: tdef; const ref: treference; reg: tregister; shuffle: pmmshuffle);
  572. var
  573. tocgsize: tcgsize;
  574. begin
  575. { records may be stored in mmregisters, but def_cgsize will return an
  576. integer size for them... }
  577. tocgsize:=getintmmcgsize(reg,def_cgmmsize(tosize));
  578. cg.a_loadmm_ref_reg(list,def_cgmmsize(fromsize),tocgsize,ref,reg,shuffle);
  579. end;
  580. procedure thlcg2ll.a_loadmm_reg_ref(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const ref: treference; shuffle: pmmshuffle);
  581. var
  582. fromcgsize: tcgsize;
  583. begin
  584. { records may be stored in mmregisters, but def_cgsize will return an
  585. integer size for them... }
  586. fromcgsize:=getintmmcgsize(reg,def_cgmmsize(fromsize));
  587. cg.a_loadmm_reg_ref(list,fromcgsize,def_cgmmsize(tosize),reg,ref,shuffle);
  588. end;
  589. procedure thlcg2ll.a_loadmm_reg_loc(list: TAsmList; fromsize, tosize: tdef; const reg: tregister; const loc: tlocation; shuffle: pmmshuffle);
  590. var
  591. fromcgsize: tcgsize;
  592. begin
  593. { sanity check }
  594. if def_cgmmsize(tosize)<>loc.size then
  595. internalerror(2012071216);
  596. { records may be stored in mmregisters, but def_cgsize will return an
  597. integer size for them... }
  598. fromcgsize:=getintmmcgsize(reg,def_cgmmsize(fromsize));
  599. cg.a_loadmm_reg_loc(list,fromcgsize,reg,loc,shuffle);
  600. end;
  601. procedure thlcg2ll.a_loadmm_reg_cgpara(list: TAsmList; fromsize: tdef; reg: tregister; const cgpara: TCGPara; shuffle: pmmshuffle);
  602. var
  603. fromcgsize: tcgsize;
  604. begin
  605. { records may be stored in mmregisters, but def_cgsize will return an
  606. integer size for them... }
  607. fromcgsize:=getintmmcgsize(reg,def_cgmmsize(fromsize));
  608. cg.a_loadmm_reg_cgpara(list,fromcgsize,reg,cgpara,shuffle);
  609. end;
  610. procedure thlcg2ll.a_loadmm_ref_cgpara(list: TAsmList; fromsize: tdef; const ref: treference; const cgpara: TCGPara; shuffle: pmmshuffle);
  611. begin
  612. cg.a_loadmm_ref_cgpara(list,def_cgmmsize(fromsize),ref,cgpara,shuffle);
  613. end;
  614. procedure thlcg2ll.a_loadmm_loc_cgpara(list: TAsmList; fromsize: tdef; const loc: tlocation; const cgpara: TCGPara; shuffle: pmmshuffle);
  615. begin
  616. { sanity check }
  617. if def_cgmmsize(fromsize)<>loc.size then
  618. internalerror(2012071220);
  619. cg.a_loadmm_loc_cgpara(list,loc,cgpara,shuffle);
  620. end;
  621. procedure thlcg2ll.a_opmm_reg_reg(list: TAsmList; Op: TOpCG; size: tdef; src, dst: tregister; shuffle: pmmshuffle);
  622. begin
  623. cg.a_opmm_reg_reg(list,op,def_cgmmsize(size),src,dst,shuffle);
  624. end;
  625. procedure thlcg2ll.a_opmm_ref_reg(list: TAsmList; Op: TOpCG; size: tdef; const ref: treference; reg: tregister; shuffle: pmmshuffle);
  626. begin
  627. cg.a_opmm_ref_reg(list,op,def_cgmmsize(size),ref,reg,shuffle);
  628. end;
  629. procedure thlcg2ll.a_opmm_loc_reg(list: TAsmList; Op: TOpCG; size: tdef; const loc: tlocation; reg: tregister; shuffle: pmmshuffle);
  630. begin
  631. cg.a_opmm_loc_reg(list,op,def_cgmmsize(size),loc,reg,shuffle);
  632. end;
  633. procedure thlcg2ll.a_opmm_reg_ref(list: TAsmList; Op: TOpCG; size: tdef; reg: tregister; const ref: treference; shuffle: pmmshuffle);
  634. begin
  635. cg.a_opmm_reg_ref(list,op,def_cgmmsize(size),reg,ref,shuffle);
  636. end;
  637. procedure thlcg2ll.a_loadmm_intreg_reg(list: TAsmList; fromsize, tosize: tdef; intreg, mmreg: tregister; shuffle: pmmshuffle);
  638. var
  639. tocgsize: tcgsize;
  640. begin
  641. { records may be stored in mmregisters, but def_cgmmsize will return an
  642. integer size for them... }
  643. tocgsize:=getintmmcgsize(mmreg,def_cgmmsize(tosize));
  644. cg.a_loadmm_intreg_reg(list,def_cgsize(fromsize),tocgsize,intreg,mmreg,shuffle);
  645. end;
  646. procedure thlcg2ll.a_loadmm_reg_intreg(list: TAsmList; fromsize, tosize: tdef; mmreg, intreg: tregister; shuffle: pmmshuffle);
  647. var
  648. fromcgsize: tcgsize;
  649. begin
  650. { records may be stored in mmregisters, but def_cgsize will return an
  651. integer size for them... }
  652. fromcgsize:=getintmmcgsize(mmreg,def_cgmmsize(fromsize));
  653. cg.a_loadmm_reg_intreg(list,fromcgsize,def_cgsize(tosize),mmreg,intreg,shuffle);
  654. end;
  655. procedure thlcg2ll.a_op_const_reg(list: TAsmList; Op: TOpCG; size: tdef; a: tcgint; reg: TRegister);
  656. begin
  657. cg.a_op_const_reg(list,op,def_cgsize(size),a,reg);
  658. end;
  659. procedure thlcg2ll.a_op_const_ref(list: TAsmList; Op: TOpCG; size: tdef; a: tcgint; const ref: TReference);
  660. begin
  661. cg.a_op_const_ref(list,op,def_cgsize(size),a,ref);
  662. end;
  663. procedure thlcg2ll.a_op_const_loc(list: TAsmList; Op: TOpCG; size: tdef; a: tcgint; const loc: tlocation);
  664. begin
  665. {$ifdef extdebug}
  666. if def_cgsize(size)<>loc.size then
  667. internalerror(2010112106);
  668. {$endif}
  669. case loc.loc of
  670. LOC_SUBSETREG,LOC_CSUBSETREG,
  671. LOC_SUBSETREF,LOC_CSUBSETREF:
  672. inherited
  673. else
  674. cg.a_op_const_loc(list,op,a,loc);
  675. end;
  676. end;
  677. procedure thlcg2ll.a_op_reg_reg(list: TAsmList; Op: TOpCG; size: tdef; reg1, reg2: TRegister);
  678. begin
  679. cg.a_op_reg_reg(list,op,def_cgsize(size),reg1,reg2);
  680. end;
  681. procedure thlcg2ll.a_op_reg_ref(list: TAsmList; Op: TOpCG; size: tdef; reg: TRegister; const ref: TReference);
  682. begin
  683. cg.a_op_reg_ref(list,op,def_cgsize(size),reg,ref);
  684. end;
  685. procedure thlcg2ll.a_op_ref_reg(list: TAsmList; Op: TOpCG; size: tdef; const ref: TReference; reg: TRegister);
  686. begin
  687. cg.a_op_ref_reg(list,op,def_cgsize(size),ref,reg);
  688. end;
  689. procedure thlcg2ll.a_op_reg_loc(list: TAsmList; Op: TOpCG; size: tdef; reg: tregister; const loc: tlocation);
  690. begin
  691. {$ifdef extdebug}
  692. if def_cgsize(size)<>loc.size then
  693. internalerror(2010112107);
  694. {$endif}
  695. case loc.loc of
  696. LOC_SUBSETREG,LOC_CSUBSETREG,
  697. LOC_SUBSETREF,LOC_CSUBSETREF:
  698. inherited
  699. else
  700. cg.a_op_reg_loc(list,op,reg,loc)
  701. end;
  702. end;
  703. procedure thlcg2ll.a_op_ref_loc(list: TAsmList; Op: TOpCG; size: tdef; const ref: TReference; const loc: tlocation);
  704. begin
  705. {$ifdef extdebug}
  706. if def_cgsize(size)<>loc.size then
  707. internalerror(2010112101);
  708. {$endif}
  709. case loc.loc of
  710. LOC_SUBSETREG,LOC_CSUBSETREG,
  711. LOC_SUBSETREF,LOC_CSUBSETREF:
  712. inherited
  713. else
  714. cg.a_op_ref_loc(list,op,ref,loc);
  715. end;
  716. end;
  717. procedure thlcg2ll.a_op_const_reg_reg(list: TAsmList; op: TOpCg; size: tdef; a: tcgint; src, dst: tregister);
  718. begin
  719. cg.a_op_const_reg_reg(list,op,def_cgsize(size),a,src,dst);
  720. end;
  721. procedure thlcg2ll.a_op_reg_reg_reg(list: TAsmList; op: TOpCg; size: tdef; src1, src2, dst: tregister);
  722. begin
  723. cg.a_op_reg_reg_reg(list,op,def_cgsize(size),src1,src2,dst);
  724. end;
  725. procedure thlcg2ll.a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tdef; a: tcgint; src, dst: tregister; setflags: boolean; var ovloc: tlocation);
  726. begin
  727. cg.a_op_const_reg_reg_checkoverflow(list,op,def_cgsize(size),a,src,dst,setflags,ovloc);
  728. end;
  729. procedure thlcg2ll.a_op_reg_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tdef; src1, src2, dst: tregister; setflags: boolean; var ovloc: tlocation);
  730. begin
  731. cg.a_op_reg_reg_reg_checkoverflow(list,op,def_cgsize(size),src1,src2,dst,setflags,ovloc);
  732. end;
  733. procedure thlcg2ll.a_cmp_const_reg_label(list: TAsmList; size: tdef; cmp_op: topcmp; a: tcgint; reg: tregister; l: tasmlabel);
  734. begin
  735. cg.a_cmp_const_reg_label(list,def_cgsize(size),cmp_op,a,reg,l);
  736. end;
  737. procedure thlcg2ll.a_cmp_const_ref_label(list: TAsmList; size: tdef; cmp_op: topcmp; a: tcgint; const ref: treference; l: tasmlabel);
  738. begin
  739. cg.a_cmp_const_ref_label(list,def_cgsize(size),cmp_op,a,ref,l);
  740. end;
  741. procedure thlcg2ll.a_cmp_const_loc_label(list: TAsmList; size: tdef; cmp_op: topcmp; a: tcgint; const loc: tlocation; l: tasmlabel);
  742. begin
  743. case loc.loc of
  744. LOC_SUBSETREG,LOC_CSUBSETREG,
  745. LOC_SUBSETREF,LOC_CSUBSETREF:
  746. inherited
  747. else
  748. cg.a_cmp_const_loc_label(list,def_cgsize(size),cmp_op,a,loc,l);
  749. end;
  750. end;
  751. procedure thlcg2ll.a_cmp_reg_reg_label(list: TAsmList; size: tdef; cmp_op: topcmp; reg1, reg2: tregister; l: tasmlabel);
  752. begin
  753. cg.a_cmp_reg_reg_label(list,def_cgsize(size),cmp_op,reg1,reg2,l);
  754. end;
  755. procedure thlcg2ll.a_cmp_ref_reg_label(list: TAsmList; size: tdef; cmp_op: topcmp; const ref: treference; reg: tregister; l: tasmlabel);
  756. begin
  757. cg.a_cmp_ref_reg_label(list,def_cgsize(size),cmp_op,ref,reg,l);
  758. end;
  759. procedure thlcg2ll.a_cmp_reg_ref_label(list: TAsmList; size: tdef; cmp_op: topcmp; reg: tregister; const ref: treference; l: tasmlabel);
  760. begin
  761. cg.a_cmp_reg_ref_label(list,def_cgsize(size),cmp_op,reg,ref,l);
  762. end;
  763. procedure thlcg2ll.a_cmp_loc_reg_label(list: TAsmList; size: tdef; cmp_op: topcmp; const loc: tlocation; reg: tregister; l: tasmlabel);
  764. begin
  765. case loc.loc of
  766. LOC_SUBSETREG,LOC_CSUBSETREG,
  767. LOC_SUBSETREF,LOC_CSUBSETREF:
  768. inherited
  769. else
  770. cg.a_cmp_loc_reg_label(list,def_cgsize(size),cmp_op,loc,reg,l);
  771. end;
  772. end;
  773. procedure thlcg2ll.a_cmp_ref_loc_label(list: TAsmList; size: tdef; cmp_op: topcmp; const ref: treference; const loc: tlocation; l: tasmlabel);
  774. begin
  775. case loc.loc of
  776. LOC_SUBSETREG,LOC_CSUBSETREG,
  777. LOC_SUBSETREF,LOC_CSUBSETREF:
  778. inherited
  779. else
  780. cg.a_cmp_ref_loc_label(list,def_cgsize(size),cmp_op,ref,loc,l);
  781. end;
  782. end;
  783. procedure thlcg2ll.a_jmp_always(list: TAsmList; l: tasmlabel);
  784. begin
  785. cg.a_jmp_always(list,l);
  786. end;
  787. {$ifdef cpuflags}
  788. procedure thlcg2ll.a_jmp_flags(list: TAsmList; const f: TResFlags; l: tasmlabel);
  789. begin
  790. cg.a_jmp_flags(list,f,l);
  791. end;
  792. procedure thlcg2ll.g_flags2reg(list: TAsmList; size: tdef; const f: tresflags; reg: TRegister);
  793. begin
  794. cg.g_flags2reg(list,def_cgsize(size),f,reg);
  795. end;
  796. procedure thlcg2ll.g_flags2ref(list: TAsmList; size: tdef; const f: tresflags; const ref: TReference);
  797. begin
  798. cg.g_flags2ref(list,def_cgsize(size),f,ref);
  799. end;
  800. {$endif cpuflags}
  801. procedure thlcg2ll.g_concatcopy(list: TAsmList; size: tdef; const source, dest: treference);
  802. begin
  803. cg.g_concatcopy(list,source,dest,size.size);
  804. end;
  805. procedure thlcg2ll.g_concatcopy_unaligned(list: TAsmList; size: tdef; const source, dest: treference);
  806. begin
  807. cg.g_concatcopy_unaligned(list,source,dest,size.size);
  808. end;
  809. procedure thlcg2ll.g_overflowcheck(list: TAsmList; const Loc: tlocation; def: tdef);
  810. begin
  811. cg.g_overflowcheck(list,loc,def);
  812. end;
  813. procedure thlcg2ll.g_overflowCheck_loc(List: TAsmList; const Loc: TLocation; def: TDef; var ovloc: tlocation);
  814. begin
  815. cg.g_overflowCheck_loc(list,loc,def,ovloc);
  816. end;
  817. procedure thlcg2ll.g_profilecode(list: TAsmList);
  818. begin
  819. cg.g_profilecode(list);
  820. end;
  821. procedure thlcg2ll.g_stackpointer_alloc(list: TAsmList; size: longint);
  822. begin
  823. cg.g_stackpointer_alloc(list,size);
  824. end;
  825. procedure thlcg2ll.g_proc_entry(list: TAsmList; localsize: longint; nostackframe: boolean);
  826. begin
  827. cg.g_proc_entry(list,localsize,nostackframe);
  828. end;
  829. procedure thlcg2ll.g_proc_exit(list: TAsmList; parasize: longint; nostackframe: boolean);
  830. begin
  831. cg.g_proc_exit(list,parasize,nostackframe);
  832. end;
  833. procedure thlcg2ll.g_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint);
  834. begin
  835. cg.g_intf_wrapper(list,procdef,labelname,ioffset);
  836. end;
  837. procedure thlcg2ll.g_adjust_self_value(list: TAsmList; procdef: tprocdef; ioffset: aint);
  838. begin
  839. cg.g_adjust_self_value(list,procdef,ioffset);
  840. end;
  841. procedure thlcg2ll.g_local_unwind(list: TAsmList; l: TAsmLabel);
  842. begin
  843. cg.g_local_unwind(list, l);
  844. end;
  845. procedure thlcg2ll.location_force_reg(list: TAsmList; var l: tlocation; src_size, dst_size: tdef; maybeconst: boolean);
  846. var
  847. {$ifndef cpu64bitalu}
  848. hregisterhi,
  849. {$endif}
  850. hregister : tregister;
  851. {$ifndef cpu64bitalu}
  852. hreg64 : tregister64;
  853. {$endif}
  854. hl: tasmlabel;
  855. oldloc : tlocation;
  856. const_location: boolean;
  857. dst_cgsize,tmpsize: tcgsize;
  858. begin
  859. oldloc:=l;
  860. dst_cgsize:=def_cgsize(dst_size);
  861. {$ifndef cpu64bitalu}
  862. { handle transformations to 64bit separate }
  863. if dst_cgsize in [OS_64,OS_S64] then
  864. begin
  865. if not (l.size in [OS_64,OS_S64]) then
  866. begin
  867. { load a smaller size to OS_64 }
  868. if l.loc=LOC_REGISTER then
  869. begin
  870. {$if defined(cpu8bitalu) or defined(cpu16bitalu)}
  871. { on avr, we cannot change the size of a register
  872. due to the nature how register with size > OS8 are handled
  873. }
  874. hregister:=cg.getintregister(list,OS_32);
  875. {$else}
  876. hregister:=cg.makeregsize(list,l.register64.reglo,OS_32);
  877. {$endif}
  878. cg.a_load_reg_reg(list,l.size,OS_32,l.register64.reglo,hregister);
  879. end
  880. else
  881. hregister:=cg.getintregister(list,OS_32);
  882. { load value in low register }
  883. case l.loc of
  884. {$ifdef cpuflags}
  885. LOC_FLAGS :
  886. begin
  887. cg.g_flags2reg(list,OS_32,l.resflags,hregister);
  888. cg.a_reg_dealloc(list,NR_DEFAULTFLAGS);
  889. end;
  890. {$endif cpuflags}
  891. LOC_JUMP :
  892. begin
  893. cg.a_label(list,current_procinfo.CurrTrueLabel);
  894. cg.a_load_const_reg(list,OS_INT,1,hregister);
  895. current_asmdata.getjumplabel(hl);
  896. cg.a_jmp_always(list,hl);
  897. cg.a_label(list,current_procinfo.CurrFalseLabel);
  898. cg.a_load_const_reg(list,OS_INT,0,hregister);
  899. cg.a_label(list,hl);
  900. {$if defined(cpu8bitalu) or defined(cpu16bitalu)}
  901. cg.a_load_reg_reg(list,OS_INT,OS_32,hregister,hregister);
  902. {$endif}
  903. end;
  904. else
  905. a_load_loc_reg(list,src_size,u32inttype,l,hregister);
  906. end;
  907. { reset hi part, take care of the signed bit of the current value }
  908. hregisterhi:=cg.getintregister(list,OS_32);
  909. if (l.size in [OS_S8,OS_S16,OS_S32]) then
  910. begin
  911. if l.loc=LOC_CONSTANT then
  912. begin
  913. if (longint(l.value)<0) then
  914. cg.a_load_const_reg(list,OS_32,longint($ffffffff),hregisterhi)
  915. else
  916. cg.a_load_const_reg(list,OS_32,0,hregisterhi);
  917. end
  918. else
  919. begin
  920. cg.a_op_const_reg_reg(list,OP_SAR,OS_32,31,hregister,
  921. hregisterhi);
  922. end;
  923. end
  924. else
  925. cg.a_load_const_reg(list,OS_32,0,hregisterhi);
  926. location_reset(l,LOC_REGISTER,dst_cgsize);
  927. l.register64.reglo:=hregister;
  928. l.register64.reghi:=hregisterhi;
  929. end
  930. else
  931. begin
  932. { 64bit to 64bit }
  933. if ((l.loc=LOC_CREGISTER) and maybeconst) then
  934. begin
  935. hregister:=l.register64.reglo;
  936. hregisterhi:=l.register64.reghi;
  937. const_location := true;
  938. end
  939. else
  940. begin
  941. hregister:=cg.getintregister(list,OS_32);
  942. hregisterhi:=cg.getintregister(list,OS_32);
  943. const_location := false;
  944. end;
  945. hreg64.reglo:=hregister;
  946. hreg64.reghi:=hregisterhi;
  947. { load value in new register }
  948. cg64.a_load64_loc_reg(list,l,hreg64);
  949. if not const_location then
  950. location_reset(l,LOC_REGISTER,dst_cgsize)
  951. else
  952. location_reset(l,LOC_CREGISTER,dst_cgsize);
  953. l.register64.reglo:=hregister;
  954. l.register64.reghi:=hregisterhi;
  955. end;
  956. end
  957. else
  958. {$endif cpu64bitalu}
  959. begin
  960. {Do not bother to recycle the existing register. The register
  961. allocator eliminates unnecessary moves, so it's not needed
  962. and trying to recycle registers can cause problems because
  963. the registers changes size and may need aditional constraints.
  964. Not if it's about LOC_CREGISTER's (JM)
  965. }
  966. const_location :=
  967. (maybeconst) and
  968. (l.loc = LOC_CREGISTER) and
  969. (TCGSize2Size[l.size] = TCGSize2Size[dst_cgsize]) and
  970. ((l.size = dst_cgsize) or
  971. (TCGSize2Size[l.size] = sizeof(aint)));
  972. if not const_location then
  973. hregister:=cg.getintregister(list,dst_cgsize)
  974. else
  975. hregister := l.register;
  976. { load value in new register }
  977. case l.loc of
  978. {$ifdef cpuflags}
  979. LOC_FLAGS :
  980. begin
  981. cg.g_flags2reg(list,dst_cgsize,l.resflags,hregister);
  982. cg.a_reg_dealloc(list,NR_DEFAULTFLAGS);
  983. end;
  984. {$endif cpuflags}
  985. LOC_JUMP :
  986. begin
  987. tmpsize:=dst_cgsize;
  988. {$if defined(cpu8bitalu) or defined(cpu16bitalu)}
  989. if TCGSize2Size[dst_cgsize]>TCGSize2Size[OS_INT] then
  990. tmpsize:=OS_INT;
  991. {$endif}
  992. cg.a_label(list,current_procinfo.CurrTrueLabel);
  993. cg.a_load_const_reg(list,tmpsize,1,hregister);
  994. current_asmdata.getjumplabel(hl);
  995. cg.a_jmp_always(list,hl);
  996. cg.a_label(list,current_procinfo.CurrFalseLabel);
  997. cg.a_load_const_reg(list,tmpsize,0,hregister);
  998. cg.a_label(list,hl);
  999. {$if defined(cpu8bitalu) or defined(cpu16bitalu)}
  1000. cg.a_load_reg_reg(list,tmpsize,dst_cgsize,hregister,hregister);
  1001. {$endif}
  1002. end;
  1003. else
  1004. begin
  1005. { load_loc_reg can only handle size >= l.size, when the
  1006. new size is smaller then we need to adjust the size
  1007. of the orignal and maybe recalculate l.register for i386 }
  1008. if (TCGSize2Size[dst_cgsize]<TCGSize2Size[l.size]) then
  1009. begin
  1010. if (l.loc in [LOC_REGISTER,LOC_CREGISTER]) then
  1011. begin
  1012. {$if defined(cpu8bitalu) or defined(cpu16bitalu)}
  1013. if TCGSize2Size[dst_cgsize]<=TCGSize2Size[OS_INT] then
  1014. {$endif}
  1015. l.register:=cg.makeregsize(list,l.register,dst_cgsize);
  1016. end;
  1017. { for big endian systems, the reference's offset must }
  1018. { be increased in this case, since they have the }
  1019. { MSB first in memory and e.g. byte(word_var) should }
  1020. { return the second byte in this case (JM) }
  1021. if (target_info.endian = ENDIAN_BIG) and
  1022. (l.loc in [LOC_REFERENCE,LOC_CREFERENCE]) then
  1023. begin
  1024. inc(l.reference.offset,TCGSize2Size[l.size]-TCGSize2Size[dst_cgsize]);
  1025. l.reference.alignment:=newalignment(l.reference.alignment,TCGSize2Size[l.size]-TCGSize2Size[dst_cgsize]);
  1026. end;
  1027. {$ifdef x86}
  1028. if not (l.loc in [LOC_SUBSETREG,LOC_CSUBSETREG]) then
  1029. begin
  1030. l.size:=dst_cgsize;
  1031. src_size:=dst_size;
  1032. end;
  1033. {$endif x86}
  1034. end;
  1035. a_load_loc_reg(list,src_size,dst_size,l,hregister);
  1036. if (TCGSize2Size[dst_cgsize]<TCGSize2Size[l.size])
  1037. {$ifdef x86}
  1038. and (l.loc in [LOC_SUBSETREG,LOC_CSUBSETREG])
  1039. {$endif x86}
  1040. then
  1041. l.size:=dst_cgsize;
  1042. end;
  1043. end;
  1044. if not const_location then
  1045. location_reset(l,LOC_REGISTER,dst_cgsize)
  1046. else
  1047. location_reset(l,LOC_CREGISTER,dst_cgsize);
  1048. l.register:=hregister;
  1049. end;
  1050. { Release temp when it was a reference }
  1051. if oldloc.loc=LOC_REFERENCE then
  1052. location_freetemp(list,oldloc);
  1053. end;
  1054. procedure thlcg2ll.location_force_mem(list: TAsmList; var l: tlocation; size: tdef);
  1055. var
  1056. r: treference;
  1057. begin
  1058. case l.loc of
  1059. LOC_FPUREGISTER,
  1060. LOC_CFPUREGISTER :
  1061. begin
  1062. { implement here using tcg because some platforms store records
  1063. in fpu registers in some cases, and a_loadfpu* can't deal with
  1064. record "size" parameters }
  1065. tg.gethltemp(list,size,size.size,tt_normal,r);
  1066. cg.a_loadfpu_reg_ref(list,l.size,l.size,l.register,r);
  1067. location_reset_ref(l,LOC_REFERENCE,l.size,0);
  1068. l.reference:=r;
  1069. end;
  1070. LOC_MMREGISTER,
  1071. LOC_CMMREGISTER:
  1072. begin
  1073. tg.gethltemp(list,size,size.size,tt_normal,r);
  1074. cg.a_loadmm_reg_ref(list,l.size,l.size,l.register,r,mms_movescalar);
  1075. location_reset_ref(l,LOC_REFERENCE,l.size,0);
  1076. l.reference:=r;
  1077. end;
  1078. LOC_CONSTANT,
  1079. LOC_REGISTER,
  1080. LOC_CREGISTER :
  1081. begin
  1082. tg.gethltemp(list,size,size.size,tt_normal,r);
  1083. {$ifdef cpu64bitalu}
  1084. if l.size in [OS_128,OS_S128] then
  1085. cg128.a_load128_loc_ref(list,l,r)
  1086. else
  1087. {$else cpu64bitalu}
  1088. if l.size in [OS_64,OS_S64] then
  1089. cg64.a_load64_loc_ref(list,l,r)
  1090. else
  1091. {$endif cpu64bitalu}
  1092. a_load_loc_ref(list,size,size,l,r);
  1093. location_reset_ref(l,LOC_REFERENCE,l.size,0);
  1094. l.reference:=r;
  1095. end;
  1096. else
  1097. inherited;
  1098. end;
  1099. end;
  1100. procedure thlcg2ll.location_force_mmregscalar(list: TAsmList; var l: tlocation; size: tdef; maybeconst: boolean);
  1101. var
  1102. reg : tregister;
  1103. href : treference;
  1104. newsize : tdef;
  1105. begin
  1106. if (l.loc<>LOC_MMREGISTER) and
  1107. ((l.loc<>LOC_CMMREGISTER) or (not maybeconst)) then
  1108. begin
  1109. { if it's in an fpu register, store to memory first }
  1110. if (l.loc in [LOC_FPUREGISTER,LOC_CFPUREGISTER]) then
  1111. begin
  1112. tg.GetTemp(list,tcgsize2size[l.size],tcgsize2size[l.size],tt_normal,href);
  1113. cg.a_loadfpu_reg_ref(list,l.size,l.size,l.register,href);
  1114. location_reset_ref(l,LOC_REFERENCE,l.size,0);
  1115. l.reference:=href;
  1116. end;
  1117. {$ifndef cpu64bitalu}
  1118. if (l.loc in [LOC_REGISTER,LOC_CREGISTER]) and
  1119. (l.size in [OS_64,OS_S64]) then
  1120. begin
  1121. reg:=cg.getmmregister(list,OS_F64);
  1122. cg64.a_loadmm_intreg64_reg(list,OS_F64,l.register64,reg);
  1123. l.size:=OS_F64;
  1124. size:=s64floattype;
  1125. end
  1126. else
  1127. {$endif not cpu64bitalu}
  1128. begin
  1129. { on ARM, CFP values may be located in integer registers,
  1130. and its second_int_to_real() also uses this routine to
  1131. force integer (memory) values in an mmregister }
  1132. if (l.size in [OS_32,OS_S32]) then
  1133. begin
  1134. size:=cgsize_orddef(l.size);
  1135. newsize:=s32floattype;
  1136. end
  1137. else if (l.size in [OS_64,OS_S64]) then
  1138. begin
  1139. size:=cgsize_orddef(l.size);
  1140. newsize:=s64floattype;
  1141. end
  1142. else
  1143. newsize:=size;
  1144. reg:=getmmregister(list,newsize);
  1145. a_loadmm_loc_reg(list,size,newsize,l,reg,mms_movescalar);
  1146. l.size:=def_cgsize(newsize);
  1147. end;
  1148. location_freetemp(list,l);
  1149. location_reset(l,LOC_MMREGISTER,l.size);
  1150. l.register:=reg;
  1151. end;
  1152. end;
  1153. (*
  1154. procedure thlcg2ll.location_force_mmreg(list: TAsmList; var l: tlocation; size: tdef; maybeconst: boolean);
  1155. begin
  1156. ncgutil.location_force_mmreg(list,l,maybeconst);
  1157. end;
  1158. *)
  1159. procedure thlcg2ll.maketojumpbool(list: TAsmList; p: tnode);
  1160. begin
  1161. { loadregvars parameter is no longer used, should be removed from
  1162. ncgutil version as well }
  1163. ncgutil.maketojumpbool(list,p,lr_dont_load_regvars);
  1164. end;
  1165. procedure thlcg2ll.gen_load_para_value(list: TAsmList);
  1166. begin
  1167. ncgutil.gen_load_para_value(list);
  1168. end;
  1169. procedure thlcg2ll.gen_loadfpu_loc_cgpara(list: TAsmList; size: tdef; const l: tlocation; const cgpara: tcgpara; locintsize: longint);
  1170. var
  1171. locsize : tcgsize;
  1172. tmploc : tlocation;
  1173. begin
  1174. if not(l.size in [OS_32,OS_S32,OS_64,OS_S64,OS_128,OS_S128]) then
  1175. locsize:=l.size
  1176. else
  1177. locsize:=int_float_cgsize(tcgsize2size[l.size]);
  1178. case l.loc of
  1179. LOC_MMREGISTER,
  1180. LOC_CMMREGISTER:
  1181. case cgpara.location^.loc of
  1182. LOC_REFERENCE,
  1183. LOC_CREFERENCE,
  1184. LOC_MMREGISTER,
  1185. LOC_CMMREGISTER,
  1186. LOC_REGISTER,
  1187. LOC_CREGISTER :
  1188. cg.a_loadmm_reg_cgpara(list,locsize,l.register,cgpara,mms_movescalar);
  1189. LOC_FPUREGISTER,
  1190. LOC_CFPUREGISTER:
  1191. begin
  1192. tmploc:=l;
  1193. location_force_fpureg(list,tmploc,size,false);
  1194. cg.a_loadfpu_reg_cgpara(list,tmploc.size,tmploc.register,cgpara);
  1195. end;
  1196. else
  1197. internalerror(200204249);
  1198. end;
  1199. LOC_FPUREGISTER,
  1200. LOC_CFPUREGISTER:
  1201. case cgpara.location^.loc of
  1202. LOC_MMREGISTER,
  1203. LOC_CMMREGISTER:
  1204. begin
  1205. tmploc:=l;
  1206. location_force_mmregscalar(list,tmploc,size,false);
  1207. cg.a_loadmm_reg_cgpara(list,tmploc.size,tmploc.register,cgpara,mms_movescalar);
  1208. end;
  1209. { Some targets pass floats in normal registers }
  1210. LOC_REGISTER,
  1211. LOC_CREGISTER,
  1212. LOC_REFERENCE,
  1213. LOC_CREFERENCE,
  1214. LOC_FPUREGISTER,
  1215. LOC_CFPUREGISTER:
  1216. cg.a_loadfpu_reg_cgpara(list,locsize,l.register,cgpara);
  1217. else
  1218. internalerror(2002042433);
  1219. end;
  1220. LOC_REFERENCE,
  1221. LOC_CREFERENCE:
  1222. case cgpara.location^.loc of
  1223. LOC_MMREGISTER,
  1224. LOC_CMMREGISTER:
  1225. cg.a_loadmm_ref_cgpara(list,locsize,l.reference,cgpara,mms_movescalar);
  1226. { Some targets pass floats in normal registers }
  1227. LOC_REGISTER,
  1228. LOC_CREGISTER,
  1229. LOC_REFERENCE,
  1230. LOC_CREFERENCE,
  1231. LOC_FPUREGISTER,
  1232. LOC_CFPUREGISTER:
  1233. cg.a_loadfpu_ref_cgpara(list,locsize,l.reference,cgpara);
  1234. else
  1235. internalerror(2002042431);
  1236. end;
  1237. LOC_REGISTER,
  1238. LOC_CREGISTER :
  1239. begin
  1240. {$ifndef cpu64bitalu}
  1241. { Only a_load_ref_cgpara supports multiple locations, when the
  1242. value is still a const or in a register then write it
  1243. to a reference first. This situation can be triggered
  1244. by typecasting an int64 constant to a record of 8 bytes }
  1245. if locsize = OS_F64 then
  1246. begin
  1247. if (cgpara.Location^.Next=nil) and (l.size in [OS_64,OS_S64]) and
  1248. (cgpara.size in [OS_64,OS_S64]) then
  1249. cg64.a_load64_reg_cgpara(list,l.register64,cgpara)
  1250. else
  1251. begin
  1252. tmploc:=l;
  1253. location_force_mem(list,tmploc,size);
  1254. cg.a_load_loc_cgpara(list,tmploc,cgpara);
  1255. location_freetemp(list,tmploc);
  1256. end;
  1257. end
  1258. else
  1259. {$endif not cpu64bitalu}
  1260. cg.a_load_loc_cgpara(list,l,cgpara);
  1261. end;
  1262. else
  1263. internalerror(2002042432);
  1264. end;
  1265. end;
  1266. procedure thlcg2ll.gen_load_loc_cgpara(list: TAsmList; vardef: tdef; const l: tlocation; const cgpara: tcgpara);
  1267. var
  1268. tmploc: tlocation;
  1269. begin
  1270. { skip e.g. empty records }
  1271. if (cgpara.location^.loc = LOC_VOID) then
  1272. exit;
  1273. { Handle Floating point types differently
  1274. This doesn't depend on emulator settings, emulator settings should
  1275. be handled by cpupara }
  1276. if (vardef.typ=floatdef) or
  1277. { some ABIs return certain records in an fpu register }
  1278. (l.loc in [LOC_FPUREGISTER,LOC_CFPUREGISTER]) or
  1279. (assigned(cgpara.location) and
  1280. (cgpara.Location^.loc in [LOC_FPUREGISTER,LOC_CFPUREGISTER])) then
  1281. begin
  1282. gen_loadfpu_loc_cgpara(list,vardef,l,cgpara,vardef.size);
  1283. exit;
  1284. end;
  1285. case l.loc of
  1286. LOC_CONSTANT,
  1287. LOC_REGISTER,
  1288. LOC_CREGISTER,
  1289. LOC_REFERENCE,
  1290. LOC_CREFERENCE :
  1291. begin
  1292. {$ifdef cpu64bitalu}
  1293. { use cg128 only if no "chained" location is used }
  1294. if is_methodpointer(cgpara.def) and (l.size in [OS_128,OS_S128]) and (cgpara.Size in [OS_128,OS_S128]) then
  1295. cg128.a_load128_loc_cgpara(list,l,cgpara)
  1296. else
  1297. {$else cpu64bitalu}
  1298. { use cg64 only for int64, not for 8 byte records }
  1299. if (l.size in [OS_64,OS_S64]) and (cgpara.Size in [OS_64,OS_S64]) then
  1300. cg64.a_load64_loc_cgpara(list,l,cgpara)
  1301. else
  1302. {$endif cpu64bitalu}
  1303. begin
  1304. { Only a_load_ref_cgpara supports multiple locations, when the
  1305. value is still a const or in a register then write it
  1306. to a reference first. This situation can be triggered
  1307. by typecasting an int64 constant to a record of 8 bytes }
  1308. {$ifdef cpu64bitalu}
  1309. if l.size in [OS_128,OS_S128] then
  1310. {$else cpu64bitalu}
  1311. if l.size in [OS_64,OS_S64] then
  1312. {$endif cpu64bitalu}
  1313. begin
  1314. tmploc:=l;
  1315. location_force_mem(list,tmploc,vardef);
  1316. a_load_loc_cgpara(list,vardef,tmploc,cgpara);
  1317. { do not free the tmploc in case the original value was
  1318. already in memory, because the caller (ncgcal) will then
  1319. free it again later }
  1320. if not(l.loc in [LOC_REFERENCE,LOC_CREFERENCE]) then
  1321. location_freetemp(list,tmploc);
  1322. end
  1323. else
  1324. a_load_loc_cgpara(list,vardef,l,cgpara);
  1325. end;
  1326. end;
  1327. LOC_MMREGISTER,
  1328. LOC_CMMREGISTER:
  1329. begin
  1330. case l.size of
  1331. OS_F32,
  1332. OS_F64:
  1333. cg.a_loadmm_loc_cgpara(list,l,cgpara,mms_movescalar);
  1334. else
  1335. cg.a_loadmm_loc_cgpara(list,l,cgpara,nil);
  1336. end;
  1337. end;
  1338. {$ifdef SUPPORT_MMX}
  1339. LOC_MMXREGISTER,
  1340. LOC_CMMXREGISTER:
  1341. cg.a_loadmm_reg_cgpara(list,OS_M64,l.register,cgpara,nil);
  1342. {$endif SUPPORT_MMX}
  1343. else
  1344. internalerror(200204241);
  1345. end;
  1346. end;
  1347. procedure thlcg2ll.gen_load_cgpara_loc(list: TAsmList; vardef: tdef; const para: TCGPara; var destloc: tlocation; reusepara: boolean);
  1348. begin
  1349. ncgutil.gen_load_cgpara_loc(list, vardef, para, destloc, reusepara);
  1350. end;
  1351. function thlcg2ll.getintmmcgsize(reg: tregister; size: tcgsize): tcgsize;
  1352. begin
  1353. result:=size;
  1354. if getregtype(reg)=R_MMREGISTER then
  1355. begin
  1356. case size of
  1357. OS_32:
  1358. result:=OS_F32;
  1359. OS_64:
  1360. result:=OS_F64;
  1361. end;
  1362. end;
  1363. end;
  1364. end.