hlcgllvm.pas 84 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134
  1. {
  2. Copyright (c) 2010, 2013 by Jonas Maebe
  3. Member of the Free Pascal development team
  4. This unit implements the LLVM high level code generator
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation; either version 2 of the License, or
  8. (at your option) any later version.
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. GNU General Public License for more details.
  13. You should have received a copy of the GNU General Public License
  14. along with this program; if not, write to the Free Software
  15. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  16. ****************************************************************************
  17. }
  18. unit hlcgllvm;
  19. {$i fpcdefs.inc}
  20. interface
  21. uses
  22. globtype,cclasses,
  23. aasmbase,aasmdata,
  24. symbase,symconst,symtype,symdef,symsym,
  25. cpubase, hlcgobj, cgbase, cgutils, parabase, tgobj;
  26. type
  27. { thlcgllvm }
  28. thlcgllvm = class(thlcgobj)
  29. constructor create;
  30. procedure a_load_ref_cgpara(list: TAsmList; size: tdef; const r: treference; const cgpara: TCGPara); override;
  31. procedure a_load_const_cgpara(list: TAsmList; tosize: tdef; a: tcgint; const cgpara: TCGPara); override;
  32. protected
  33. procedure a_load_ref_cgpara_init_src(list: TAsmList; const para: tcgpara; const initialref: treference; var refsize: tdef; out newref: treference);
  34. public
  35. procedure getcpuregister(list: TAsmList; r: Tregister); override;
  36. procedure ungetcpuregister(list: TAsmList; r: Tregister); override;
  37. procedure alloccpuregisters(list: TAsmList; rt: Tregistertype; const r: Tcpuregisterset); override;
  38. procedure allocallcpuregisters(list: TAsmList); override;
  39. procedure deallocallcpuregisters(list: TAsmList); override;
  40. procedure a_bit_test_reg_reg_reg(list: TAsmList; bitnumbersize, valuesize, destsize: tdef; bitnumber, value, destreg: tregister); override;
  41. procedure a_bit_set_reg_reg(list: TAsmList; doset: boolean; bitnumbersize, destsize: tdef; bitnumber, dest: tregister); override;
  42. protected
  43. procedure a_call_common(list: TAsmList; pd: tabstractprocdef; const paras: array of pcgpara; const forceresdef: tdef; out res: tregister; out hlretdef: tdef; out llvmretdef: tdef; out callparas: tfplist);
  44. public
  45. function a_call_name(list : TAsmList;pd : tprocdef;const s : TSymStr; const paras: array of pcgpara; forceresdef: tdef; weak: boolean): tcgpara;override;
  46. function a_call_reg(list: TAsmList; pd: tabstractprocdef; reg: tregister; const paras: array of pcgpara): tcgpara; override;
  47. procedure a_load_const_reg(list : TAsmList;tosize : tdef;a : tcgint;register : tregister);override;
  48. procedure a_load_const_ref(list: TAsmList; tosize: tdef; a: tcgint; const ref: treference);override;
  49. procedure a_load_reg_ref(list : TAsmList;fromsize, tosize : tdef;register : tregister;const ref : treference);override;
  50. procedure a_load_reg_reg(list : TAsmList;fromsize, tosize : tdef;reg1,reg2 : tregister);override;
  51. protected
  52. procedure gen_load_refaddrfull_anyreg(list: TAsmList; fromsize, tosize : tdef; const simpleref: treference; register: tregister; shuffle: pmmshuffle);
  53. function handle_agg_load_ref_anyreg(list: TasmList; var fromsize, tosize: tdef; var simpleref: treference; register: tregister; shuffle: pmmshuffle): boolean;
  54. public
  55. procedure a_load_ref_reg(list : TAsmList;fromsize, tosize : tdef;const ref : treference;register : tregister);override;
  56. procedure a_load_ref_ref(list: TAsmList; fromsize, tosize: tdef; const sref: treference; const dref: treference); override;
  57. protected
  58. procedure a_loadaddr_ref_reg_intern(list : TAsmList;fromsize, tosize : tdef;const ref : treference;r : tregister; makefromsizepointer: boolean);
  59. public
  60. procedure a_loadaddr_ref_reg(list : TAsmList;fromsize, tosize : tdef;const ref : treference;r : tregister);override;
  61. procedure a_op_const_reg(list: TAsmList; Op: TOpCG; size: tdef; a: tcgint; reg: TRegister); override;
  62. procedure a_op_const_reg_reg(list: TAsmList; op: TOpCg; size: tdef; a: tcgint; src, dst: tregister); override;
  63. procedure a_op_reg_reg_reg(list: TAsmList; op: TOpCg; size: tdef; src1, src2, dst: tregister); override;
  64. procedure a_op_reg_reg(list: TAsmList; Op: TOpCG; size: tdef; reg1, reg2: TRegister); override;
  65. procedure a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tdef; a: tcgint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); override;
  66. procedure a_op_reg_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tdef; src1, src2, dst: tregister;setflags : boolean;var ovloc : tlocation); override;
  67. procedure a_cmp_const_reg_label(list: TAsmList; size: tdef; cmp_op: topcmp; a: tcgint; reg: tregister; l: tasmlabel); override;
  68. procedure a_cmp_reg_reg_label(list: TAsmList; size: tdef; cmp_op: topcmp; reg1, reg2: tregister; l: tasmlabel); override;
  69. procedure a_jmp_always(list : TAsmList;l: tasmlabel); override;
  70. procedure g_unreachable(list: TAsmList); override;
  71. procedure g_concatcopy(list : TAsmList;size: tdef; const source,dest : treference);override;
  72. procedure a_loadfpu_ref_reg(list: TAsmList; fromsize, tosize: tdef; const ref: treference; reg: tregister); override;
  73. procedure a_loadfpu_reg_ref(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const ref: treference); override;
  74. procedure a_loadfpu_reg_reg(list: TAsmList; fromsize, tosize: tdef; reg1, reg2: tregister); override;
  75. procedure gen_proc_symbol(list: TAsmList); override;
  76. procedure handle_external_proc(list: TAsmList; pd: tprocdef; const importname: TSymStr); override;
  77. procedure g_proc_entry(list : TAsmList;localsize : longint;nostackframe:boolean); override;
  78. procedure g_proc_exit(list : TAsmList;parasize:longint;nostackframe:boolean); override;
  79. protected
  80. procedure gen_load_uninitialized_function_result(list: TAsmList; pd: tprocdef; resdef: tdef; const resloc: tcgpara); override;
  81. public
  82. procedure g_overflowcheck(list: TAsmList; const Loc: tlocation; def: tdef); override;
  83. procedure g_overflowCheck_loc(List:TAsmList;const Loc:TLocation;def:TDef;var ovloc : tlocation); override;
  84. procedure g_ptrtypecast_reg(list: TAsmList; fromdef, todef: tdef; var reg: tregister); override;
  85. procedure g_ptrtypecast_ref(list: TAsmList; fromdef, todef: tdef; var ref: treference); override;
  86. procedure g_set_addr_nonbitpacked_field_ref(list: TAsmList; recdef: tabstractrecorddef; field: tfieldvarsym; var recref: treference); override;
  87. procedure a_loadmm_ref_reg(list: TAsmList; fromsize, tosize: tdef; const ref: treference; reg: tregister; shuffle: pmmshuffle); override;
  88. procedure a_loadmm_reg_ref(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const ref: treference; shuffle: pmmshuffle); override;
  89. procedure a_loadmm_reg_reg(list: TAsmList; fromsize, tosize: tdef; reg1, reg2: tregister; shuffle: pmmshuffle); override;
  90. procedure a_opmm_reg_reg(list: TAsmList; Op: TOpCG; size: tdef; src, dst: tregister; shuffle: pmmshuffle); override;
  91. procedure a_loadmm_intreg_reg(list: TAsmList; fromsize, tosize: tdef; intreg, mmreg: tregister; shuffle: pmmshuffle); override;
  92. procedure a_loadmm_reg_intreg(list: TAsmList; fromsize, tosize: tdef; mmreg, intreg: tregister; shuffle: pmmshuffle); override;
  93. function get_call_result_cgpara(pd: tabstractprocdef; forceresdef: tdef): tcgpara; override;
  94. protected
  95. procedure gen_load_loc_function_result(list: TAsmList; vardef: tdef; const l: tlocation); override;
  96. public
  97. procedure gen_load_loc_cgpara(list: TAsmList; vardef: tdef; const l: tlocation; const cgpara: tcgpara); override;
  98. procedure gen_load_cgpara_loc(list: TAsmList; vardef: tdef; const para: TCGPara; var destloc: tlocation; reusepara: boolean); override;
  99. {$ifdef cpuflags}
  100. { llvm doesn't have flags, but cpuflags is defined in case the real cpu
  101. has flags and we have to override the abstract methods to prevent
  102. warnings }
  103. procedure a_jmp_flags(list: TAsmList; const f: TResFlags; l: tasmlabel); override;
  104. procedure g_flags2reg(list: TAsmList; size: tdef; const f: tresflags; reg: TRegister); override;
  105. procedure g_flags2ref(list: TAsmList; size: tdef; const f: tresflags; const ref: TReference); override;
  106. {$endif cpuflags}
  107. { unimplemented or unnecessary routines }
  108. procedure a_bit_scan_reg_reg(list: TAsmList; reverse: boolean; srcsize, dstsize: tdef; src, dst: tregister); override;
  109. procedure g_stackpointer_alloc(list: TAsmList; size: longint); override;
  110. procedure g_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint); override;
  111. procedure g_adjust_self_value(list: TAsmList; procdef: tprocdef; ioffset: aint); override;
  112. procedure g_local_unwind(list: TAsmList; l: TAsmLabel); override;
  113. procedure gen_stack_check_size_para(list: TAsmList); override;
  114. procedure gen_stack_check_call(list: TAsmList); override;
  115. procedure varsym_set_localloc(list: TAsmList; vs: tabstractnormalvarsym); override;
  116. procedure paravarsym_set_initialloc_to_paraloc(vs: tparavarsym); override;
  117. procedure g_external_wrapper(list: TAsmList; procdef: tprocdef; const wrappername, externalname: string; global: boolean); override;
  118. { def is a pointerdef or implicit pointer type (class, classref, procvar,
  119. dynamic array, ...). }
  120. function make_simple_ref_ptr(list: TAsmList; const ref: treference; ptrdef: tdef): treference;
  121. { def is the type of the data stored in memory pointed to by ref, not
  122. a pointer to this type }
  123. function make_simple_ref(list: TAsmList; const ref: treference; def: tdef): treference;
  124. protected
  125. procedure paraloctoloc(const paraloc: pcgparalocation; out hloc: tlocation);
  126. procedure set_call_function_result(const list: TAsmList; const pd: tabstractprocdef; const llvmretdef, hlretdef: tdef; const resval: tregister; var retpara: tcgpara);
  127. end;
  128. implementation
  129. uses
  130. verbose,cutils,globals,fmodule,constexp,systems,
  131. defutil,llvmdef,llvmsym,
  132. aasmtai,aasmcpu,
  133. aasmllvm,llvmbase,llvminfo,tgllvm,
  134. symtable,symllvm,
  135. paramgr,
  136. pass_2,procinfo,llvmpi,cpuinfo,cgobj,cgllvm,cghlcpu,
  137. cgcpu,hlcgcpu;
  138. var
  139. create_hlcodegen_cpu: TProcedure = nil;
  140. const
  141. topcg2llvmop: array[topcg] of tllvmop =
  142. { OP_NONE OP_MOVE OP_ADD OP_AND OP_DIV OP_IDIV OP_IMUL OP_MUL }
  143. (la_none, la_none, la_add, la_and, la_udiv, la_sdiv, la_mul, la_mul,
  144. { OP_NEG OP_NOT OP_OR OP_SAR OP_SHL OP_SHR OP_SUB OP_XOR }
  145. la_none, la_none, la_or, la_ashr, la_shl, la_lshr, la_sub, la_xor,
  146. { OP_ROL OP_ROR }
  147. la_none, la_none);
  148. constructor thlcgllvm.create;
  149. begin
  150. inherited
  151. end;
  152. procedure thlcgllvm.a_load_ref_cgpara(list: TAsmList; size: tdef; const r: treference; const cgpara: TCGPara);
  153. var
  154. tmpref, initialref, ref: treference;
  155. fielddef,
  156. orgsize: tdef;
  157. location: pcgparalocation;
  158. sizeleft,
  159. totaloffset: asizeint;
  160. paralocidx: longint;
  161. userecord: boolean;
  162. begin
  163. location:=cgpara.location;
  164. sizeleft:=cgpara.intsize;
  165. totaloffset:=0;
  166. orgsize:=size;
  167. a_load_ref_cgpara_init_src(list,cgpara,r,size,initialref);
  168. if initialref.refaddr=addr_full then
  169. begin
  170. cgpara.check_simple_location;
  171. location^.llvmvalueloc:=true;
  172. location^.llvmloc.loc:=LOC_CREFERENCE;
  173. location^.llvmloc.sym:=initialref.symbol;
  174. exit;
  175. end;
  176. userecord:=
  177. (orgsize<>size) and
  178. assigned(cgpara.location^.next);
  179. paralocidx:=0;
  180. fielddef:=nil;
  181. while assigned(location) do
  182. begin
  183. if userecord then
  184. begin
  185. { llvmparadef is a record in this case, with every field
  186. corresponding to a single paraloc (fielddef is unused, because
  187. it will be equivalent to location^.def -- see below) }
  188. g_setup_load_field_by_name(list,trecorddef(size),'F'+tostr(paralocidx),initialref,tmpref,fielddef);
  189. end
  190. else
  191. tmpref:=initialref;
  192. paramanager.allocparaloc(list,location);
  193. case location^.loc of
  194. LOC_REGISTER,LOC_CREGISTER:
  195. begin
  196. { byval parameter -> load the address rather than the value }
  197. if not location^.llvmvalueloc then
  198. a_loadaddr_ref_reg(list,tpointerdef(location^.def).pointeddef,location^.def,tmpref,location^.register)
  199. { if this parameter is split into multiple paralocs via
  200. record fields, load the current paraloc. The type of the
  201. paraloc and of the current record field will match by
  202. construction (the record is build from the paraloc
  203. types) }
  204. else if userecord then
  205. a_load_ref_reg(list,fielddef,location^.def,tmpref,location^.register)
  206. { if the parameter is passed in a single paraloc, the
  207. paraloc's type may be different from the declared type
  208. -> use the original complete parameter size as source so
  209. we can insert a type conversion if necessary }
  210. else
  211. a_load_ref_reg(list,size,location^.def,tmpref,location^.register)
  212. end;
  213. LOC_REFERENCE,LOC_CREFERENCE:
  214. begin
  215. if assigned(location^.next) then
  216. internalerror(2010052906);
  217. reference_reset_base(ref,cpointerdef.getreusable(size),location^.reference.index,location^.reference.offset,ctempposinvalid,newalignment(cgpara.alignment,cgpara.intsize-sizeleft),[]);
  218. if (def_cgsize(size)<>OS_NO) and
  219. (size.size=sizeleft) and
  220. (sizeleft<=sizeof(aint)) then
  221. a_load_ref_ref(list,size,location^.def,tmpref,ref)
  222. else
  223. { use concatcopy, because the parameter can be larger than }
  224. { what the OS_* constants can handle }
  225. g_concatcopy(list,location^.def,tmpref,ref);
  226. end;
  227. LOC_MMREGISTER,LOC_CMMREGISTER:
  228. begin
  229. case location^.size of
  230. OS_F32,
  231. OS_F64,
  232. OS_F128:
  233. a_loadmm_ref_reg(list,location^.def,location^.def,tmpref,location^.register,mms_movescalar);
  234. OS_M8..OS_M128,
  235. OS_MS8..OS_MS128,
  236. OS_32..OS_128,
  237. { OS_NO is for records of non-power-of-two sizes that have to
  238. be passed in MM registers -> never scalar floats }
  239. OS_NO:
  240. a_loadmm_ref_reg(list,location^.def,location^.def,tmpref,location^.register,nil);
  241. else
  242. internalerror(2010053101);
  243. end;
  244. end
  245. else
  246. internalerror(2010053111);
  247. end;
  248. inc(totaloffset,tcgsize2size[location^.size]);
  249. dec(sizeleft,tcgsize2size[location^.size]);
  250. location:=location^.next;
  251. inc(paralocidx);
  252. end;
  253. end;
  254. procedure thlcgllvm.a_load_const_cgpara(list: TAsmList; tosize: tdef; a: tcgint; const cgpara: TCGPara);
  255. begin
  256. if is_ordinal(cgpara.def) then
  257. begin
  258. cgpara.check_simple_location;
  259. paramanager.alloccgpara(list,cgpara);
  260. if cgpara.location^.shiftval<0 then
  261. a:=a shl -cgpara.location^.shiftval;
  262. cgpara.location^.llvmloc.loc:=LOC_CONSTANT;
  263. cgpara.location^.llvmloc.value:=a;
  264. end
  265. else
  266. inherited;
  267. end;
  268. procedure thlcgllvm.a_load_ref_cgpara_init_src(list: TAsmList; const para: tcgpara; const initialref: treference; var refsize: tdef; out newref: treference);
  269. var
  270. newrefsize: tdef;
  271. reg: tregister;
  272. begin
  273. newrefsize:=llvmgetcgparadef(para,true,callerside);
  274. if (refsize<>newrefsize) and
  275. (initialref.refaddr<>addr_full) then
  276. begin
  277. reg:=getaddressregister(list,cpointerdef.getreusable(newrefsize));
  278. a_loadaddr_ref_reg(list,refsize,cpointerdef.getreusable(newrefsize),initialref,reg);
  279. reference_reset_base(newref,cpointerdef.getreusable(newrefsize),reg,0,initialref.temppos,initialref.alignment,initialref.volatility);
  280. refsize:=newrefsize;
  281. end
  282. else
  283. newref:=initialref;
  284. end;
  285. procedure thlcgllvm.getcpuregister(list: TAsmList; r: Tregister);
  286. begin
  287. { don't do anything }
  288. end;
  289. procedure thlcgllvm.ungetcpuregister(list: TAsmList; r: Tregister);
  290. begin
  291. { don't do anything }
  292. end;
  293. procedure thlcgllvm.alloccpuregisters(list: TAsmList; rt: Tregistertype; const r: Tcpuregisterset);
  294. begin
  295. { don't do anything }
  296. end;
  297. procedure thlcgllvm.allocallcpuregisters(list: TAsmList);
  298. begin
  299. { don't do anything }
  300. end;
  301. procedure thlcgllvm.deallocallcpuregisters(list: TAsmList);
  302. begin
  303. { don't do anything }
  304. end;
  305. procedure thlcgllvm.a_bit_test_reg_reg_reg(list: TAsmList; bitnumbersize, valuesize, destsize: tdef; bitnumber, value, destreg: tregister);
  306. var
  307. tmpbitnumberreg: tregister;
  308. begin
  309. { unlike other architectures, llvm requires the bitnumber register to
  310. have the same size as the shifted register }
  311. if bitnumbersize.size<>valuesize.size then
  312. begin
  313. tmpbitnumberreg:=hlcg.getintregister(list,valuesize);
  314. a_load_reg_reg(list,bitnumbersize,valuesize,bitnumber,tmpbitnumberreg);
  315. bitnumbersize:=valuesize;
  316. bitnumber:=tmpbitnumberreg;
  317. end;
  318. inherited;
  319. end;
  320. procedure thlcgllvm.a_bit_set_reg_reg(list: TAsmList; doset: boolean; bitnumbersize, destsize: tdef; bitnumber, dest: tregister);
  321. var
  322. tmpbitnumberreg: tregister;
  323. begin
  324. { unlike other architectures, llvm requires the bitnumber register to
  325. have the same size as the shifted register }
  326. if bitnumbersize.size<>destsize.size then
  327. begin
  328. tmpbitnumberreg:=hlcg.getintregister(list,destsize);
  329. a_load_reg_reg(list,bitnumbersize,destsize,bitnumber,tmpbitnumberreg);
  330. bitnumbersize:=destsize;
  331. bitnumber:=tmpbitnumberreg;
  332. end;
  333. inherited;
  334. end;
  335. function get_call_pd(pd: tabstractprocdef): tdef;
  336. begin
  337. if (pd.typ=procdef) or
  338. not pd.is_addressonly then
  339. { we get a pointerdef rather than a procvardef so that if we have to
  340. insert an external declaration for this procdef in llvmtype, we don't
  341. have to create another procdef from the procvardef we've just created.
  342. With a pointerdef, we can just get the pointeddef again. A pointerdef
  343. is also much cheaper to create, and in llvm a provardef is a "function
  344. pointer", so a pointer to a procdef is the same as a procvar as far
  345. as llvm is concerned }
  346. result:=cpointerdef.getreusable(pd)
  347. else
  348. result:=pd
  349. end;
  350. procedure thlcgllvm.a_call_common(list: TAsmList; pd: tabstractprocdef; const paras: array of pcgpara; const forceresdef: tdef; out res: tregister; out hlretdef: tdef; out llvmretdef: tdef; out callparas: tfplist);
  351. procedure load_ref_anyreg(def: tdef; const ref: treference; reg: tregister);
  352. begin
  353. case getregtype(reg) of
  354. R_INTREGISTER,
  355. R_ADDRESSREGISTER:
  356. begin
  357. a_load_ref_reg(list,def,def,ref,reg);
  358. end;
  359. R_FPUREGISTER:
  360. begin
  361. a_loadfpu_ref_reg(list,def,def,ref,reg);
  362. end;
  363. R_MMREGISTER:
  364. begin
  365. a_loadmm_ref_reg(list,def,def,ref,reg,mms_movescalar);
  366. end;
  367. else
  368. internalerror(2014012213);
  369. end;
  370. end;
  371. var
  372. i: longint;
  373. href: treference;
  374. callpara: pllvmcallpara;
  375. paraloc: pcgparalocation;
  376. firstparaloc: boolean;
  377. begin
  378. callparas:=tfplist.Create;
  379. for i:=0 to high(paras) do
  380. begin
  381. { skip parameters without data }
  382. if paras[i]^.isempty then
  383. continue;
  384. paraloc:=paras[i]^.location;
  385. firstparaloc:=true;
  386. while assigned(paraloc) do
  387. begin
  388. new(callpara);
  389. callpara^.def:=paraloc^.def;
  390. if firstparaloc then
  391. callpara^.alignment:=paras[i]^.Alignment
  392. else
  393. callpara^.alignment:=std_param_align;
  394. { if the paraloc doesn't contain the value itself, it's a byval
  395. parameter }
  396. if paraloc^.retvalloc then
  397. begin
  398. callpara^.sret:=true;
  399. callpara^.byval:=false;
  400. end
  401. else
  402. begin
  403. callpara^.sret:=false;
  404. callpara^.byval:=not paraloc^.llvmvalueloc;
  405. end;
  406. llvmextractvalueextinfo(paras[i]^.def, callpara^.def, callpara^.valueext);
  407. case paraloc^.llvmloc.loc of
  408. LOC_CONSTANT:
  409. begin
  410. callpara^.typ:=top_const;
  411. callpara^.value:=paraloc^.llvmloc.value;
  412. end;
  413. LOC_CREFERENCE:
  414. begin
  415. callpara^.typ:=top_ref;
  416. callpara^.sym:=paraloc^.llvmloc.sym;
  417. end
  418. else
  419. begin
  420. case paraloc^.loc of
  421. LOC_REFERENCE:
  422. begin
  423. if paraloc^.llvmvalueloc then
  424. internalerror(2014012307)
  425. else
  426. begin
  427. callpara^.typ:=top_reg;
  428. reference_reset_base(href, cpointerdef.getreusable(callpara^.def), paraloc^.reference.index, paraloc^.reference.offset, ctempposinvalid, paraloc^.def.alignment, []);
  429. res:=getregisterfordef(list, paraloc^.def);
  430. load_ref_anyreg(callpara^.def, href, res);
  431. end;
  432. callpara^.register:=res
  433. end;
  434. LOC_REGISTER,
  435. LOC_FPUREGISTER,
  436. LOC_MMREGISTER:
  437. begin
  438. callpara^.typ:=top_reg;
  439. { undo explicit value extension }
  440. if callpara^.valueext<>lve_none then
  441. begin
  442. res:=getregisterfordef(list, callpara^.def);
  443. a_load_reg_reg(list, paraloc^.def, callpara^.def, paraloc^.register, res);
  444. paraloc^.register:=res;
  445. end;
  446. callpara^.register:=paraloc^.register
  447. end;
  448. { empty records }
  449. LOC_VOID:
  450. begin
  451. callpara^.typ:=top_undef;
  452. end
  453. else
  454. internalerror(2014010605);
  455. end;
  456. end;
  457. end;
  458. callparas.add(callpara);
  459. paraloc:=paraloc^.next;
  460. firstparaloc:=false;
  461. end;
  462. end;
  463. { the Pascal level may expect a different returndef compared to the
  464. declared one }
  465. if pd.generate_safecall_wrapper then
  466. begin
  467. hlretdef:=ossinttype;
  468. llvmretdef:=ossinttype;
  469. end
  470. else
  471. begin
  472. if not assigned(forceresdef) then
  473. hlretdef:=pd.returndef
  474. else
  475. hlretdef:=forceresdef;
  476. { llvm will always expect the original return def }
  477. if not paramanager.ret_in_param(hlretdef, pd) or
  478. pd.generate_safecall_wrapper then
  479. llvmretdef:=llvmgetcgparadef(pd.funcretloc[callerside], true, callerside)
  480. else
  481. llvmretdef:=voidtype;
  482. end;
  483. if not is_void(llvmretdef) then
  484. res:=getregisterfordef(list, llvmretdef)
  485. else
  486. res:=NR_NO;
  487. { if this is a complex procvar, get the non-tmethod-like equivalent }
  488. if (pd.typ=procvardef) and
  489. not pd.is_addressonly then
  490. pd:=tprocvardef(cprocvardef.getreusableprocaddr(pd));
  491. end;
  492. function thlcgllvm.a_call_name(list: TAsmList; pd: tprocdef; const s: TSymStr; const paras: array of pcgpara; forceresdef: tdef; weak: boolean): tcgpara;
  493. var
  494. callparas: tfplist;
  495. llvmretdef,
  496. hlretdef: tdef;
  497. res: tregister;
  498. nextinslab,
  499. exceptlab: TAsmLabel;
  500. begin
  501. a_call_common(list,pd,paras,forceresdef,res,hlretdef,llvmretdef,callparas);
  502. if not(fc_catching_exceptions in flowcontrol) or
  503. { no invoke for intrinsics }
  504. (copy(s,1,5)='llvm.') then
  505. list.concat(taillvm.call_size_name_paras(get_call_pd(pd),pd.proccalloption,res,llvmretdef,current_asmdata.RefAsmSymbol(s,AT_FUNCTION),callparas))
  506. else
  507. begin
  508. current_asmdata.getjumplabel(nextinslab);
  509. exceptlab:=tllvmprocinfo(current_procinfo).CurrExceptLabel;
  510. list.concat(taillvm.invoke_size_name_paras_retlab_exceptlab(get_call_pd(pd),pd.proccalloption,res,llvmretdef,current_asmdata.RefAsmSymbol(s,AT_FUNCTION),callparas,nextinslab,exceptlab));
  511. a_label(list,nextinslab);
  512. end;
  513. result:=get_call_result_cgpara(pd,forceresdef);
  514. set_call_function_result(list,pd,llvmretdef,hlretdef,res,result);
  515. end;
  516. function thlcgllvm.a_call_reg(list: TAsmList; pd: tabstractprocdef; reg: tregister; const paras: array of pcgpara): tcgpara;
  517. var
  518. callparas: tfplist;
  519. llvmretdef,
  520. hlretdef: tdef;
  521. res: tregister;
  522. nextinslab,
  523. exceptlab: TAsmLabel;
  524. begin
  525. a_call_common(list,pd,paras,nil,res,hlretdef,llvmretdef,callparas);
  526. if not(fc_catching_exceptions in flowcontrol) then
  527. list.concat(taillvm.call_size_reg_paras(get_call_pd(pd),pd.proccalloption,res,llvmretdef,reg,callparas))
  528. else
  529. begin
  530. current_asmdata.getjumplabel(nextinslab);
  531. exceptlab:=tllvmprocinfo(current_procinfo).CurrExceptLabel;
  532. list.concat(taillvm.invoke_size_reg_paras_retlab_exceptlab(get_call_pd(pd),pd.proccalloption,res,llvmretdef,reg,callparas,nextinslab,exceptlab));
  533. a_label(list,nextinslab);
  534. end;
  535. result:=get_call_result_cgpara(pd,nil);
  536. set_call_function_result(list,pd,llvmretdef,hlretdef,res,result);
  537. end;
  538. procedure thlcgllvm.a_load_const_reg(list: TAsmList; tosize: tdef; a: tcgint; register: tregister);
  539. var
  540. fromsize: tdef;
  541. begin
  542. if tosize.size<=ptrsinttype.size then
  543. fromsize:=ptrsinttype
  544. else
  545. fromsize:=tosize;
  546. list.concat(taillvm.op_reg_size_const_size(llvmconvop(fromsize,tosize,false),register,fromsize,a,tosize))
  547. end;
  548. procedure thlcgllvm.a_load_const_ref(list: TAsmList; tosize: tdef; a: tcgint; const ref: treference);
  549. var
  550. sref: treference;
  551. begin
  552. { llvm instructions do not support pointer constants -> only directly
  553. encode for integers; a_load_const_reg() handles pointers properly }
  554. if is_ordinal(tosize) or
  555. is_64bit(tosize) then
  556. begin
  557. sref:=make_simple_ref(list,ref,tosize);
  558. list.concat(taillvm.op_size_const_size_ref(la_store,tosize,a,cpointerdef.getreusable(tosize),sref))
  559. end
  560. else
  561. inherited;
  562. end;
  563. function def2intdef(fromsize, tosize: tdef): tdef;
  564. begin
  565. { we cannot zero-extend from/to anything but ordinal/enum
  566. types }
  567. if not(tosize.typ in [orddef,enumdef]) then
  568. internalerror(2014012305);
  569. { will give an internalerror if def_cgsize() returns OS_NO, which is
  570. what we want }
  571. result:=cgsize_orddef(def_cgsize(fromsize));
  572. end;
  573. procedure thlcgllvm.a_load_reg_ref(list: TAsmList; fromsize, tosize: tdef; register: tregister; const ref: treference);
  574. var
  575. tmpref,
  576. sref: treference;
  577. hreg,
  578. hreg2: tregister;
  579. tmpsize: tdef;
  580. begin
  581. sref:=make_simple_ref(list,ref,tosize);
  582. hreg:=register;
  583. (* typecast the pointer to the value instead of the value itself if
  584. they have the same size but are of different kinds, because we can't
  585. e.g. typecast a loaded <{i32, i32}> to an i64 *)
  586. if (llvmaggregatetype(fromsize) or
  587. llvmaggregatetype(tosize)) and
  588. (fromsize<>tosize) then
  589. begin
  590. if fromsize.size>tosize.size then
  591. begin
  592. { if source size is larger than the target size, we have to
  593. truncate it before storing. Unfortunately, we cannot truncate
  594. records (nor bitcast them to integers), so we first have to
  595. store them to memory and then bitcast the pointer to them
  596. We can't truncate an integer to 3/5/6/7 bytes either, so also
  597. pass via a temp in that case
  598. }
  599. if (fromsize.typ in [arraydef,recorddef]) or
  600. (tosize.size in [3,5,6,7]) then
  601. begin
  602. { store struct/array-in-register to memory }
  603. tg.gethltemp(list,fromsize,fromsize.size,tt_normal,tmpref);
  604. a_load_reg_ref(list,fromsize,fromsize,register,tmpref);
  605. { typecast pointer to memory into pointer to integer type }
  606. hreg:=getaddressregister(list,cpointerdef.getreusable(tosize));
  607. a_loadaddr_ref_reg(list,fromsize,cpointerdef.getreusable(tosize),tmpref,hreg);
  608. reference_reset_base(sref,cpointerdef.getreusable(tosize),hreg,0,tmpref.temppos,tmpref.alignment,tmpref.volatility);
  609. { load the integer from the temp into the destination }
  610. a_load_ref_ref(list,tosize,tosize,sref,ref);
  611. tg.ungettemp(list,tmpref);
  612. end
  613. else
  614. begin
  615. tmpsize:=def2intdef(tosize,fromsize);
  616. hreg:=getintregister(list,tmpsize);
  617. { truncate the integer }
  618. a_load_reg_reg(list,fromsize,tmpsize,register,hreg);
  619. { store it to memory (it will now be of the same size as the
  620. struct, and hence another path will be followed in this
  621. method) }
  622. a_load_reg_ref(list,tmpsize,tosize,hreg,sref);
  623. end;
  624. exit;
  625. end
  626. else
  627. begin
  628. hreg2:=getaddressregister(list,cpointerdef.getreusable(fromsize));
  629. a_loadaddr_ref_reg(list,tosize,cpointerdef.getreusable(fromsize),sref,hreg2);
  630. reference_reset_base(sref,cpointerdef.getreusable(fromsize),hreg2,0,sref.temppos,sref.alignment,sref.volatility);
  631. tosize:=fromsize;
  632. end;
  633. end
  634. else if fromsize<>tosize then
  635. begin
  636. hreg:=getregisterfordef(list,tosize);
  637. a_load_reg_reg(list,fromsize,tosize,register,hreg);
  638. end;
  639. list.concat(taillvm.op_size_reg_size_ref(la_store,tosize,hreg,cpointerdef.getreusable(tosize),sref));
  640. end;
  641. procedure thlcgllvm.a_load_reg_reg(list: TAsmList; fromsize, tosize: tdef; reg1, reg2: tregister);
  642. var
  643. op: tllvmop;
  644. tmpreg: tregister;
  645. tmpintdef: tdef;
  646. begin
  647. op:=llvmconvop(fromsize,tosize,true);
  648. { converting from pointer to something else and vice versa is only
  649. possible via an intermediate pass to integer. Same for "something else"
  650. to pointer. }
  651. case op of
  652. la_ptrtoint_to_x,
  653. la_x_to_inttoptr:
  654. begin
  655. { convert via an integer with the same size as "x" }
  656. if op=la_ptrtoint_to_x then
  657. begin
  658. tmpintdef:=cgsize_orddef(def_cgsize(tosize));
  659. op:=la_bitcast
  660. end
  661. else
  662. begin
  663. tmpintdef:=cgsize_orddef(def_cgsize(fromsize));
  664. op:=la_inttoptr;
  665. end;
  666. tmpreg:=getintregister(list,tmpintdef);
  667. a_load_reg_reg(list,fromsize,tmpintdef,reg1,tmpreg);
  668. reg1:=tmpreg;
  669. fromsize:=tmpintdef;
  670. end;
  671. else
  672. ;
  673. end;
  674. { reg2 = bitcast fromsize reg1 to tosize }
  675. list.concat(taillvm.op_reg_size_reg_size(op,reg2,fromsize,reg1,tosize));
  676. end;
  677. procedure thlcgllvm.gen_load_refaddrfull_anyreg(list: TAsmList; fromsize, tosize: tdef; const simpleref: treference; register: tregister; shuffle: pmmshuffle);
  678. var
  679. tmpref,
  680. tmpref2: treference;
  681. begin
  682. { can't bitcast records/arrays }
  683. if (llvmaggregatetype(fromsize) or
  684. llvmaggregatetype(tosize)) and
  685. (fromsize<>tosize) then
  686. begin
  687. if fromsize.size>tosize.size then
  688. begin
  689. tg.gethltemp(list,fromsize,fromsize.size,tt_normal,tmpref);
  690. tmpref2:=tmpref;
  691. g_ptrtypecast_ref(list,cpointerdef.getreusable(fromsize),cpointerdef.getreusable(tosize),tmpref2);
  692. end
  693. else
  694. begin
  695. tg.gethltemp(list,tosize,tosize.size,tt_normal,tmpref);
  696. tmpref2:=tmpref;
  697. g_ptrtypecast_ref(list,cpointerdef.getreusable(tosize),cpointerdef.getreusable(fromsize),tmpref);
  698. end;
  699. list.concat(taillvm.op_size_ref_size_ref(la_store,fromsize,simpleref,cpointerdef.getreusable(fromsize),tmpref));
  700. case getregtype(register) of
  701. R_INTREGISTER,
  702. R_ADDRESSREGISTER:
  703. a_load_ref_reg(list,tosize,tosize,tmpref2,register);
  704. R_FPUREGISTER:
  705. a_loadfpu_ref_reg(list,tosize,tosize,tmpref2,register);
  706. R_MMREGISTER:
  707. a_loadmm_ref_reg(list,tosize,tosize,tmpref2,register,shuffle);
  708. else
  709. internalerror(2016061901);
  710. end;
  711. tg.ungettemp(list,tmpref);
  712. end
  713. else
  714. list.concat(taillvm.op_reg_size_ref_size(llvmconvop(fromsize,tosize,false),register,fromsize,simpleref,tosize))
  715. end;
  716. function thlcgllvm.handle_agg_load_ref_anyreg(list: TasmList; var fromsize, tosize: tdef; var simpleref: treference; register: tregister; shuffle: pmmshuffle): boolean;
  717. var
  718. tmpref,
  719. tmpref2: treference;
  720. firstshuffle: pmmshuffle;
  721. begin
  722. if fromsize.size<tosize.size then
  723. begin
  724. { allocate a temp of size tosize, typecast it to the
  725. (smaller) fromsize, load the source in it, and then
  726. load the destination from it. The extra bits will contain
  727. garbage, but they should never be used. }
  728. tg.gethltemp(list,tosize,tosize.size,tt_persistent,tmpref);
  729. tmpref2:=tmpref;
  730. g_ptrtypecast_ref(list,cpointerdef.getreusable(tosize),cpointerdef.getreusable(fromsize),tmpref2);
  731. case getregtype(register) of
  732. R_INTREGISTER,
  733. R_ADDRESSREGISTER:
  734. begin
  735. a_load_ref_ref(list,fromsize,fromsize,simpleref,tmpref2);
  736. a_load_ref_reg(list,tosize,tosize,tmpref,register);
  737. end;
  738. R_FPUREGISTER:
  739. begin
  740. a_loadfpu_ref_ref(list,fromsize,fromsize,simpleref,tmpref2);
  741. a_loadfpu_ref_reg(list,tosize,tosize,tmpref,register);
  742. end;
  743. R_MMREGISTER:
  744. begin
  745. { don't shuffle twice }
  746. if shuffle=mms_movescalar then
  747. firstshuffle:=shuffle
  748. else
  749. firstshuffle:=nil;
  750. a_loadmm_ref_ref(list,fromsize,fromsize,simpleref,tmpref2,firstshuffle);
  751. a_loadmm_ref_reg(list,tosize,tosize,tmpref,register,shuffle);
  752. end;
  753. else
  754. internalerror(2019051040);
  755. end;
  756. tg.ungettemp(list,tmpref);
  757. result:=true;
  758. end
  759. else
  760. begin
  761. (* typecast the pointer to the value instead of the value
  762. itself if tosize<=fromsize but they are of different
  763. kinds, because we can't e.g. bitcast a loaded <{i32, i32}>
  764. to an i64 *)
  765. g_ptrtypecast_ref(list,cpointerdef.getreusable(fromsize),cpointerdef.getreusable(tosize),simpleref);
  766. fromsize:=tosize;
  767. result:=false;
  768. end;
  769. end;
  770. procedure thlcgllvm.a_load_ref_reg(list: TAsmList; fromsize, tosize: tdef; const ref: treference; register: tregister);
  771. var
  772. sref: treference;
  773. hreg: tregister;
  774. begin
  775. sref:=make_simple_ref(list,ref,fromsize);
  776. { "named register"? }
  777. if sref.refaddr=addr_full then
  778. gen_load_refaddrfull_anyreg(list,fromsize,tosize,sref,register,nil)
  779. else
  780. begin
  781. if ((fromsize.typ in [arraydef,recorddef]) or
  782. (tosize.typ in [arraydef,recorddef])) and
  783. (fromsize<>tosize) then
  784. begin
  785. if handle_agg_load_ref_anyreg(list,fromsize,tosize,sref,register,nil) then
  786. exit;
  787. end;
  788. hreg:=register;
  789. if fromsize<>tosize then
  790. hreg:=getregisterfordef(list,fromsize);
  791. list.concat(taillvm.op_reg_size_ref(la_load,hreg,cpointerdef.getreusable(fromsize),sref));
  792. if hreg<>register then
  793. a_load_reg_reg(list,fromsize,tosize,hreg,register);
  794. end;
  795. end;
  796. procedure thlcgllvm.a_load_ref_ref(list: TAsmList; fromsize, tosize: tdef; const sref: treference; const dref: treference);
  797. var
  798. sdref: treference;
  799. begin
  800. if (fromsize=tosize) and
  801. (sref.refaddr=addr_full) then
  802. begin
  803. sdref:=make_simple_ref(list,dref,tosize);
  804. list.concat(taillvm.op_size_ref_size_ref(la_store,fromsize,sref,cpointerdef.getreusable(tosize),sdref));
  805. end
  806. else if (fromsize=tosize) and
  807. not(fromsize.typ in [orddef,floatdef,enumdef]) and
  808. (sref.refaddr<>addr_full) and
  809. (fromsize.size>2*sizeof(aint)) then
  810. g_concatcopy(list,fromsize,sref,dref)
  811. else
  812. inherited
  813. end;
  814. procedure thlcgllvm.a_loadaddr_ref_reg_intern(list: TAsmList; fromsize, tosize: tdef; const ref: treference; r: tregister; makefromsizepointer: boolean);
  815. var
  816. sref: treference;
  817. begin
  818. { can't take the address of a 'named register' }
  819. if ref.refaddr=addr_full then
  820. internalerror(2013102306);
  821. if makefromsizepointer then
  822. fromsize:=cpointerdef.getreusable(fromsize);
  823. sref:=make_simple_ref_ptr(list,ref,fromsize);
  824. list.concat(taillvm.op_reg_size_ref_size(la_bitcast,r,fromsize,sref,tosize));
  825. end;
  826. procedure thlcgllvm.a_loadaddr_ref_reg(list: TAsmList; fromsize, tosize: tdef; const ref: treference; r: tregister);
  827. begin
  828. a_loadaddr_ref_reg_intern(list,fromsize,tosize,ref,r,true);
  829. end;
  830. procedure thlcgllvm.a_op_const_reg(list: TAsmList; Op: TOpCG; size: tdef; a: tcgint; reg: TRegister);
  831. begin
  832. a_op_const_reg_reg(list,op,size,a,reg,reg);
  833. end;
  834. procedure thlcgllvm.a_op_const_reg_reg(list: TAsmList; op: TOpCg; size: tdef; a: tcgint; src, dst: tregister);
  835. var
  836. tmpreg: tregister;
  837. begin
  838. if (def2regtyp(size)=R_INTREGISTER) and
  839. (topcg2llvmop[op]<>la_none) then
  840. list.concat(taillvm.op_reg_size_reg_const(topcg2llvmop[op],dst,size,src,a))
  841. else
  842. begin
  843. { default implementation is not SSA-safe }
  844. tmpreg:=getregisterfordef(list,size);
  845. a_load_const_reg(list,size,a,tmpreg);
  846. a_op_reg_reg_reg(list,op,size,tmpreg,src,dst);
  847. end;
  848. end;
  849. procedure thlcgllvm.a_op_reg_reg_reg(list: TAsmList; op: TOpCg; size: tdef; src1, src2, dst: tregister);
  850. var
  851. orgdst,
  852. tmpreg1,
  853. tmpreg2,
  854. tmpreg3: tregister;
  855. opsize: tdef;
  856. begin
  857. orgdst:=dst;
  858. opsize:=size;
  859. { always perform using integer registers, because math operations on
  860. pointers are not supported (except via getelementptr, possible future
  861. optimization) }
  862. if def2regtyp(size)=R_ADDRESSREGISTER then
  863. begin
  864. opsize:=ptruinttype;
  865. tmpreg1:=getintregister(list,ptruinttype);
  866. a_load_reg_reg(list,size,ptruinttype,src1,tmpreg1);
  867. src1:=tmpreg1;
  868. tmpreg1:=getintregister(list,ptruinttype);
  869. a_load_reg_reg(list,size,ptruinttype,src2,tmpreg1);
  870. src2:=tmpreg1;
  871. dst:=getintregister(list,ptruinttype);
  872. end;
  873. if topcg2llvmop[op]<>la_none then
  874. list.concat(taillvm.op_reg_size_reg_reg(topcg2llvmop[op],dst,opsize,src2,src1))
  875. else
  876. begin
  877. case op of
  878. OP_NEG:
  879. { %dst = sub size 0, %src1 }
  880. list.concat(taillvm.op_reg_size_const_reg(la_sub,dst,opsize,0,src1));
  881. OP_NOT:
  882. { %dst = xor size -1, %src1 }
  883. list.concat(taillvm.op_reg_size_const_reg(la_xor,dst,opsize,-1,src1));
  884. OP_ROL:
  885. begin
  886. tmpreg1:=getintregister(list,opsize);
  887. tmpreg2:=getintregister(list,opsize);
  888. tmpreg3:=getintregister(list,opsize);
  889. { tmpreg1 := (tcgsize2size[size]*8 - (src1 and (tcgsize2size[size]*8-1) }
  890. list.concat(taillvm.op_reg_size_const_reg(la_and,tmpreg1,opsize,opsize.size*8-1,src1));
  891. list.concat(taillvm.op_reg_size_const_reg(la_sub,tmpreg2,opsize,opsize.size*8,tmpreg1));
  892. { tmpreg3 := src2 shr tmpreg2 }
  893. a_op_reg_reg_reg(list,OP_SHR,opsize,tmpreg2,src2,tmpreg3);
  894. { tmpreg2:= src2 shl tmpreg1 }
  895. tmpreg2:=getintregister(list,opsize);
  896. a_op_reg_reg_reg(list,OP_SHL,opsize,tmpreg1,src2,tmpreg2);
  897. { dst := tmpreg2 or tmpreg3 }
  898. a_op_reg_reg_reg(list,OP_OR,opsize,tmpreg2,tmpreg3,dst);
  899. end;
  900. OP_ROR:
  901. begin
  902. tmpreg1:=getintregister(list,size);
  903. tmpreg2:=getintregister(list,size);
  904. tmpreg3:=getintregister(list,size);
  905. { tmpreg1 := (tcgsize2size[size]*8 - (src1 and (tcgsize2size[size]*8-1) }
  906. list.concat(taillvm.op_reg_size_const_reg(la_and,tmpreg1,opsize,opsize.size*8-1,src1));
  907. list.concat(taillvm.op_reg_size_const_reg(la_sub,tmpreg2,opsize,opsize.size*8,tmpreg1));
  908. { tmpreg3 := src2 shl tmpreg2 }
  909. a_op_reg_reg_reg(list,OP_SHL,opsize,tmpreg2,src2,tmpreg3);
  910. { tmpreg2:= src2 shr tmpreg1 }
  911. tmpreg2:=getintregister(list,opsize);
  912. a_op_reg_reg_reg(list,OP_SHR,opsize,tmpreg1,src2,tmpreg2);
  913. { dst := tmpreg2 or tmpreg3 }
  914. a_op_reg_reg_reg(list,OP_OR,opsize,tmpreg2,tmpreg3,dst);
  915. end;
  916. else
  917. internalerror(2010081310);
  918. end;
  919. end;
  920. if dst<>orgdst then
  921. a_load_reg_reg(list,opsize,size,dst,orgdst);
  922. end;
  923. procedure thlcgllvm.a_op_reg_reg(list: TAsmList; Op: TOpCG; size: tdef; reg1, reg2: TRegister);
  924. begin
  925. a_op_reg_reg_reg(list,op,size,reg1,reg2,reg2);
  926. end;
  927. procedure thlcgllvm.a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tdef; a: tcgint; src, dst: tregister; setflags: boolean; var ovloc: tlocation);
  928. var
  929. hreg: tregister;
  930. begin
  931. if not setflags then
  932. begin
  933. inherited;
  934. exit;
  935. end;
  936. hreg:=getintregister(list,size);
  937. a_load_const_reg(list,size,a,hreg);
  938. a_op_reg_reg_reg_checkoverflow(list,op,size,hreg,src,dst,setflags,ovloc);
  939. end;
  940. procedure thlcgllvm.a_op_reg_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tdef; src1, src2, dst: tregister; setflags: boolean; var ovloc: tlocation);
  941. var
  942. calcsize: tdef;
  943. tmpsrc1,
  944. tmpsrc2,
  945. tmpdst: tregister;
  946. signed,
  947. docheck: boolean;
  948. begin
  949. docheck:=size.size>=ossinttype.size;
  950. if not setflags or
  951. not docheck then
  952. begin
  953. inherited a_op_reg_reg_reg_checkoverflow(list,op,size,src1,src2,dst,false,ovloc);
  954. exit;
  955. end;
  956. { extend values to twice their original width (one bit extra is enough,
  957. but adding support for 9/17/33/65 bit types just for this is overkill) }
  958. signed:=is_signed(size);
  959. case size.size of
  960. 1:
  961. if signed then
  962. calcsize:=s16inttype
  963. else
  964. calcsize:=u16inttype;
  965. 2:
  966. if signed then
  967. calcsize:=s32inttype
  968. else
  969. calcsize:=u32inttype;
  970. 4:
  971. if signed then
  972. calcsize:=s64inttype
  973. else
  974. calcsize:=u64inttype;
  975. 8:
  976. if signed then
  977. calcsize:=s128inttype
  978. else
  979. calcsize:=u128inttype;
  980. else
  981. internalerror(2015122503);
  982. end;
  983. tmpsrc1:=getintregister(list,calcsize);
  984. a_load_reg_reg(list,size,calcsize,src1,tmpsrc1);
  985. tmpsrc2:=getintregister(list,calcsize);
  986. a_load_reg_reg(list,size,calcsize,src2,tmpsrc2);
  987. tmpdst:=getintregister(list,calcsize);
  988. { perform the calculation with twice the width }
  989. a_op_reg_reg_reg(list,op,calcsize,tmpsrc1,tmpsrc2,tmpdst);
  990. { signed/unsigned overflow occurs if signed/unsigned truncation of the
  991. result is different from the actual result -> extend again and compare }
  992. a_load_reg_reg(list,calcsize,size,tmpdst,dst);
  993. tmpsrc1:=getintregister(list,calcsize);
  994. a_load_reg_reg(list,size,calcsize,dst,tmpsrc1);
  995. location_reset(ovloc,LOC_REGISTER,OS_8);
  996. ovloc.register:=getintregister(list,llvmbool1type);
  997. list.concat(taillvm.op_reg_cond_size_reg_reg(la_icmp,ovloc.register,OC_NE,calcsize,tmpsrc1,tmpdst));
  998. end;
  999. procedure thlcgllvm.a_cmp_const_reg_label(list: TAsmList; size: tdef; cmp_op: topcmp; a: tcgint; reg: tregister; l: tasmlabel);
  1000. var
  1001. tmpreg : tregister;
  1002. invert: boolean;
  1003. fallthroughlab, falselab, tmplab: tasmlabel;
  1004. begin
  1005. tmpreg:=getregisterfordef(list,size);
  1006. a_load_const_reg(list,size,a,tmpreg);
  1007. a_cmp_reg_reg_label(list,size,cmp_op,tmpreg,reg,l);
  1008. end;
  1009. procedure thlcgllvm.a_cmp_reg_reg_label(list: TAsmList; size: tdef; cmp_op: topcmp; reg1, reg2: tregister; l: tasmlabel);
  1010. var
  1011. resreg: tregister;
  1012. falselab: tasmlabel;
  1013. begin
  1014. if getregtype(reg1)<>getregtype(reg2) then
  1015. internalerror(2012111105);
  1016. resreg:=getintregister(list,llvmbool1type);
  1017. current_asmdata.getjumplabel(falselab);
  1018. { invert order of registers. In FPC, cmp_reg_reg(reg1,reg2) means that
  1019. e.g. OC_GT is true if "subl %reg1,%reg2" in x86 AT&T is >0. In LLVM,
  1020. OC_GT is true if op1>op2 }
  1021. list.concat(taillvm.op_reg_cond_size_reg_reg(la_icmp,resreg,cmp_op,size,reg2,reg1));
  1022. list.concat(taillvm.op_size_reg_lab_lab(la_br,llvmbool1type,resreg,l,falselab));
  1023. a_label(list,falselab);
  1024. end;
  1025. procedure thlcgllvm.a_jmp_always(list: TAsmList; l: tasmlabel);
  1026. begin
  1027. { implement in tcg because required by the overridden a_label; doesn't use
  1028. any high level stuff anyway }
  1029. cg.a_jmp_always(list,l);
  1030. end;
  1031. procedure thlcgllvm.g_unreachable(list: TAsmList);
  1032. begin
  1033. list.Concat(taillvm.op_none(la_unreachable));
  1034. end;
  1035. procedure thlcgllvm.g_concatcopy(list: TAsmList; size: tdef; const source, dest: treference);
  1036. var
  1037. pd: tprocdef;
  1038. sourcepara, destpara, sizepara, alignpara, volatilepara: tcgpara;
  1039. maxalign: longint;
  1040. indivalign: boolean;
  1041. begin
  1042. { perform small copies directly; not larger ones, because then llvm
  1043. will try to load the entire large datastructure into registers and
  1044. starts spilling like crazy; too small copies must not be done via
  1045. llvm.memcpy either, because then you get crashes in llvm }
  1046. if (size.typ in [orddef,floatdef,enumdef]) or
  1047. (size.size<=2*sizeof(aint)) then
  1048. begin
  1049. a_load_ref_ref(list,size,size,source,dest);
  1050. exit;
  1051. end;
  1052. indivalign:=llvmflag_memcpy_indiv_align in llvmversion_properties[current_settings.llvmversion];
  1053. if indivalign then
  1054. pd:=search_system_proc('llvm_memcpy64_indivalign')
  1055. else
  1056. pd:=search_system_proc('llvm_memcpy64');
  1057. sourcepara.init;
  1058. destpara.init;
  1059. sizepara.init;
  1060. alignpara.init;
  1061. volatilepara.init;
  1062. paramanager.getcgtempparaloc(list,pd,1,destpara);
  1063. paramanager.getcgtempparaloc(list,pd,2,sourcepara);
  1064. paramanager.getcgtempparaloc(list,pd,3,sizepara);
  1065. if indivalign then
  1066. begin
  1067. paramanager.getcgtempparaloc(list,pd,4,volatilepara);
  1068. destpara.Alignment:=-dest.alignment;
  1069. sourcepara.Alignment:=-source.alignment;
  1070. end
  1071. else
  1072. begin
  1073. paramanager.getcgtempparaloc(list,pd,4,alignpara);
  1074. paramanager.getcgtempparaloc(list,pd,5,volatilepara);
  1075. maxalign:=newalignment(max(source.alignment,dest.alignment),min(source.alignment,dest.alignment));
  1076. a_load_const_cgpara(list,u32inttype,maxalign,alignpara);
  1077. end;
  1078. a_loadaddr_ref_cgpara(list,size,dest,destpara);
  1079. a_loadaddr_ref_cgpara(list,size,source,sourcepara);
  1080. a_load_const_cgpara(list,u64inttype,size.size,sizepara);
  1081. a_load_const_cgpara(list,llvmbool1type,ord((vol_read in source.volatility) or (vol_write in dest.volatility)),volatilepara);
  1082. if indivalign then
  1083. g_call_system_proc(list,pd,[@destpara,@sourcepara,@sizepara,@volatilepara],nil).resetiftemp
  1084. else
  1085. g_call_system_proc(list,pd,[@destpara,@sourcepara,@sizepara,@alignpara,@volatilepara],nil).resetiftemp;
  1086. sourcepara.done;
  1087. destpara.done;
  1088. sizepara.done;
  1089. alignpara.done;
  1090. volatilepara.done;
  1091. end;
  1092. procedure thlcgllvm.a_loadfpu_ref_reg(list: TAsmList; fromsize, tosize: tdef; const ref: treference; reg: tregister);
  1093. var
  1094. tmpreg: tregister;
  1095. href: treference;
  1096. fromcompcurr,
  1097. tocompcurr: boolean;
  1098. begin
  1099. href:=make_simple_ref(list,ref,fromsize);
  1100. { named register -> use generic code }
  1101. if ref.refaddr=addr_full then
  1102. begin
  1103. gen_load_refaddrfull_anyreg(list,fromsize,tosize,href,reg,mms_movescalar);
  1104. exit
  1105. end;
  1106. { comp and currency are handled by the x87 in this case. They cannot
  1107. be represented directly in llvm, and llvmdef translates them into i64
  1108. (since that's their storage size and internally they also are int64).
  1109. Solve this by changing the type to s80real once they are loaded into
  1110. a register. }
  1111. fromcompcurr:=
  1112. (fromsize.typ=floatdef) and
  1113. (tfloatdef(fromsize).floattype in [s64comp,s64currency]);
  1114. tocompcurr:=
  1115. (tosize.typ=floatdef) and
  1116. (tfloatdef(tosize).floattype in [s64comp,s64currency]);
  1117. if tocompcurr then
  1118. tosize:=s80floattype;
  1119. { don't generate different code for loading e.g. extended into cextended,
  1120. but to take care of loading e.g. comp (=int64) into double }
  1121. if (fromsize.size<>tosize.size) then
  1122. tmpreg:=getfpuregister(list,fromsize)
  1123. else
  1124. tmpreg:=reg;
  1125. { handle aggregate loads (happens if a struct needs to be passed in a
  1126. floating point register) }
  1127. if (fromsize.typ in [arraydef,recorddef]) or
  1128. (tosize.typ in [arraydef,recorddef]) then
  1129. begin
  1130. if handle_agg_load_ref_anyreg(list,fromsize,tosize,href,reg,mms_movescalar) then
  1131. exit;
  1132. end;
  1133. { %tmpreg = load size* %ref }
  1134. list.concat(taillvm.op_reg_size_ref(la_load,tmpreg,cpointerdef.getreusable(fromsize),href));
  1135. if tmpreg<>reg then
  1136. if fromcompcurr then
  1137. { treat as extended as long as it's in a register }
  1138. list.concat(taillvm.op_reg_size_reg_size(la_sitofp,reg,fromsize,tmpreg,tosize))
  1139. else
  1140. a_loadfpu_reg_reg(list,fromsize,tosize,tmpreg,reg);
  1141. end;
  1142. procedure thlcgllvm.a_loadfpu_reg_ref(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const ref: treference);
  1143. var
  1144. tmpreg: tregister;
  1145. href: treference;
  1146. fromcompcurr,
  1147. tocompcurr: boolean;
  1148. begin
  1149. { see comment in a_loadfpu_ref_reg }
  1150. fromcompcurr:=
  1151. (fromsize.typ=floatdef) and
  1152. (tfloatdef(fromsize).floattype in [s64comp,s64currency]);
  1153. tocompcurr:=
  1154. (tosize.typ=floatdef) and
  1155. (tfloatdef(tosize).floattype in [s64comp,s64currency]);
  1156. if fromcompcurr then
  1157. fromsize:=s80floattype;
  1158. href:=make_simple_ref(list,ref,tosize);
  1159. { don't generate different code for loading e.g. extended into cextended,
  1160. but to take care of storing e.g. comp (=int64) into double }
  1161. if (fromsize.size<>tosize.size) then
  1162. begin
  1163. tmpreg:=getfpuregister(list,tosize);
  1164. if tocompcurr then
  1165. { store back an int64 rather than an extended }
  1166. list.concat(taillvm.op_reg_size_reg_size(la_fptosi,tmpreg,fromsize,reg,tosize))
  1167. else
  1168. a_loadfpu_reg_reg(list,fromsize,tosize,reg,tmpreg);
  1169. end
  1170. else
  1171. tmpreg:=reg;
  1172. { store tosize tmpreg, tosize* href }
  1173. list.concat(taillvm.op_size_reg_size_ref(la_store,tosize,tmpreg,cpointerdef.getreusable(tosize),href));
  1174. end;
  1175. procedure thlcgllvm.a_loadfpu_reg_reg(list: TAsmList; fromsize, tosize: tdef; reg1, reg2: tregister);
  1176. var
  1177. op: tllvmop;
  1178. begin
  1179. op:=llvmconvop(fromsize,tosize,true);
  1180. { reg2 = bitcast fromllsize reg1 to tollsize }
  1181. list.concat(taillvm.op_reg_size_reg_size(op,reg2,fromsize,reg1,tosize));
  1182. end;
  1183. procedure thlcgllvm.gen_proc_symbol(list: TAsmList);
  1184. var
  1185. item: TCmdStrListItem;
  1186. mangledname: TSymStr;
  1187. asmsym: tasmsymbol;
  1188. begin
  1189. if po_external in current_procinfo.procdef.procoptions then
  1190. exit;
  1191. item:=TCmdStrListItem(current_procinfo.procdef.aliasnames.first);
  1192. mangledname:=current_procinfo.procdef.mangledname;
  1193. { predefine the real function name as local/global, so the aliases can
  1194. refer to the symbol and get the binding correct }
  1195. if (cs_profile in current_settings.moduleswitches) or
  1196. (po_global in current_procinfo.procdef.procoptions) then
  1197. asmsym:=current_asmdata.DefineAsmSymbol(mangledname,AB_GLOBAL,AT_FUNCTION,current_procinfo.procdef)
  1198. else
  1199. asmsym:=current_asmdata.DefineAsmSymbol(mangledname,AB_LOCAL,AT_FUNCTION,current_procinfo.procdef);
  1200. while assigned(item) do
  1201. begin
  1202. if mangledname<>item.Str then
  1203. list.concat(taillvmalias.create(asmsym,item.str,current_procinfo.procdef,asmsym.bind));
  1204. item:=TCmdStrListItem(item.next);
  1205. end;
  1206. list.concat(taillvmdecl.createdef(asmsym,current_procinfo.procdef,nil,sec_code,current_procinfo.procdef.alignment));
  1207. end;
  1208. procedure thlcgllvm.handle_external_proc(list: TAsmList; pd: tprocdef; const importname: TSymStr);
  1209. begin
  1210. { don't do anything, because at this point we can't know yet for certain
  1211. whether the aliased routine is internal to the current routine or not.
  1212. If it's internal, we would have to generate an llvm alias, while if it's
  1213. external, we would have to generate a declaration. Additionally, aliases
  1214. cannot refer to declarations, so always creating aliases doesn't work
  1215. either -> handle in llvmtype }
  1216. end;
  1217. procedure thlcgllvm.g_proc_entry(list: TAsmList; localsize: longint; nostackframe: boolean);
  1218. begin
  1219. list.concatlist(ttgllvm(tg).alloclist)
  1220. { rest: todo }
  1221. end;
  1222. procedure thlcgllvm.g_proc_exit(list: TAsmList; parasize: longint; nostackframe: boolean);
  1223. var
  1224. retdef: tdef;
  1225. retreg,
  1226. hreg: tregister;
  1227. retpara: tcgpara;
  1228. begin
  1229. { the function result type is the type of the first location, which can
  1230. differ from the real result type (e.g. int64 for a record consisting of
  1231. two longint fields on x86-64 -- we are responsible for lowering the
  1232. result types like that) }
  1233. retpara:=get_call_result_cgpara(current_procinfo.procdef,nil);
  1234. retpara.check_simple_location;
  1235. retdef:=retpara.location^.def;
  1236. if (is_void(retdef) or
  1237. { don't check retdef here, it is e.g. a pshortstring in case it's
  1238. shortstring that's returned in a parameter }
  1239. paramanager.ret_in_param(current_procinfo.procdef.returndef,current_procinfo.procdef)) and
  1240. not current_procinfo.procdef.generate_safecall_wrapper then
  1241. list.concat(taillvm.op_size(la_ret,voidtype))
  1242. else
  1243. begin
  1244. case retpara.location^.loc of
  1245. LOC_REGISTER,
  1246. LOC_FPUREGISTER,
  1247. LOC_MMREGISTER:
  1248. begin
  1249. { sign/zeroextension of function results is handled implicitly
  1250. via the signext/zeroext modifiers of the result, rather than
  1251. in the code generator -> remove any explicit extensions here }
  1252. retreg:=retpara.location^.register;
  1253. if (current_procinfo.procdef.returndef.typ in [orddef,enumdef]) and
  1254. (retdef.typ in [orddef,enumdef]) and
  1255. not current_procinfo.procdef.generate_safecall_wrapper then
  1256. begin
  1257. if (current_procinfo.procdef.returndef.size<retpara.location^.def.size) then
  1258. begin
  1259. hreg:=getintregister(list,current_procinfo.procdef.returndef);
  1260. a_load_reg_reg(list,retdef,current_procinfo.procdef.returndef,retreg,hreg);
  1261. retreg:=hreg;
  1262. retdef:=current_procinfo.procdef.returndef;
  1263. end;
  1264. end;
  1265. list.concat(taillvm.op_size_reg(la_ret,retdef,retreg))
  1266. end;
  1267. LOC_VOID:
  1268. begin
  1269. { zero-sized records: return an undefined zero-sized record of
  1270. the correct type }
  1271. list.concat(taillvm.op_size_undef(la_ret,retdef));
  1272. end
  1273. else
  1274. { todo: complex returns }
  1275. internalerror(2012111106);
  1276. end;
  1277. end;
  1278. retpara.resetiftemp;
  1279. end;
  1280. procedure thlcgllvm.gen_load_uninitialized_function_result(list: TAsmList; pd: tprocdef; resdef: tdef; const resloc: tcgpara);
  1281. begin
  1282. if not paramanager.ret_in_param(resdef,pd) then
  1283. begin
  1284. case resloc.location^.loc of
  1285. LOC_REGISTER,
  1286. LOC_FPUREGISTER,
  1287. LOC_MMREGISTER:
  1288. begin
  1289. if not llvmaggregatetype(resdef) then
  1290. list.concat(taillvm.op_reg_size_undef(la_bitcast,resloc.location^.register,llvmgetcgparadef(resloc,true,calleeside)))
  1291. else
  1292. { bitcast doesn't work for aggregates -> just load from the
  1293. (uninitialised) function result memory location }
  1294. gen_load_loc_function_result(list,resdef,tabstractnormalvarsym(pd.funcretsym).localloc)
  1295. end;
  1296. { for empty record returns }
  1297. LOC_VOID:
  1298. ;
  1299. else
  1300. internalerror(2015042301);
  1301. end;
  1302. end;
  1303. end;
  1304. procedure thlcgllvm.g_overflowcheck(list: TAsmList; const Loc: tlocation; def: tdef);
  1305. begin
  1306. { not possible, need ovloc }
  1307. internalerror(2012111107);
  1308. end;
  1309. procedure thlcgllvm.g_overflowCheck_loc(List: TAsmList; const Loc: TLocation; def: TDef; var ovloc: tlocation);
  1310. var
  1311. hl: tasmlabel;
  1312. begin
  1313. if not(cs_check_overflow in current_settings.localswitches) then
  1314. exit;
  1315. if ovloc.size<>OS_8 then
  1316. internalerror(2015122504);
  1317. current_asmdata.getjumplabel(hl);
  1318. a_cmp_const_loc_label(list,llvmbool1type,OC_EQ,0,ovloc,hl);
  1319. g_call_system_proc(list,'fpc_overflow',[],nil).resetiftemp;
  1320. a_label(list,hl);
  1321. end;
  1322. procedure thlcgllvm.g_ptrtypecast_reg(list: TAsmList; fromdef, todef: tdef; var reg: tregister);
  1323. var
  1324. hreg: tregister;
  1325. begin
  1326. { will insert a bitcast if necessary }
  1327. if fromdef<>todef then
  1328. begin
  1329. hreg:=getregisterfordef(list,todef);
  1330. a_load_reg_reg(list,fromdef,todef,reg,hreg);
  1331. reg:=hreg;
  1332. end;
  1333. end;
  1334. procedure thlcgllvm.g_ptrtypecast_ref(list: TAsmList; fromdef, todef: tdef; var ref: treference);
  1335. var
  1336. hreg: tregister;
  1337. begin
  1338. hreg:=getaddressregister(list,todef);
  1339. a_loadaddr_ref_reg_intern(list,fromdef,todef,ref,hreg,false);
  1340. reference_reset_base(ref,todef,hreg,0,ref.temppos,ref.alignment,ref.volatility);
  1341. end;
  1342. procedure thlcgllvm.g_set_addr_nonbitpacked_field_ref(list: TAsmList; recdef: tabstractrecorddef; field: tfieldvarsym; var recref: treference);
  1343. var
  1344. parentdef,
  1345. subscriptdef,
  1346. currentstructdef,
  1347. llvmfielddef: tdef;
  1348. llvmfield: tllvmshadowsymtableentry;
  1349. newbase: tregister;
  1350. implicitpointer: boolean;
  1351. begin
  1352. implicitpointer:=is_implicit_pointer_object_type(recdef);
  1353. currentstructdef:=recdef;
  1354. { in case the field is part of a parent of the current object,
  1355. index into the parents until we're at the parent containing the
  1356. field; if it's an implicit pointer type, these embedded parents
  1357. will be of the structure type of the class rather than of the
  1358. class time itself -> one indirection fewer }
  1359. while field.owner<>tabstractrecorddef(currentstructdef).symtable do
  1360. begin
  1361. { only objectdefs have parents and hence the owner of the
  1362. fieldvarsym can be different from the current def's owner }
  1363. parentdef:=tobjectdef(currentstructdef).childof;
  1364. if implicitpointer then
  1365. newbase:=getaddressregister(list,parentdef)
  1366. else
  1367. newbase:=getaddressregister(list,cpointerdef.getreusable(parentdef));
  1368. recref:=make_simple_ref(list,recref,recdef);
  1369. if implicitpointer then
  1370. subscriptdef:=currentstructdef
  1371. else
  1372. subscriptdef:=cpointerdef.getreusable(currentstructdef);
  1373. { recurse into the first field }
  1374. list.concat(taillvm.getelementptr_reg_size_ref_size_const(newbase,subscriptdef,recref,s32inttype,0,true));
  1375. reference_reset_base(recref,subscriptdef,newbase,field.offsetfromllvmfield,recref.temppos,newalignment(recref.alignment,field.fieldoffset),recref.volatility);
  1376. { go to the parent }
  1377. currentstructdef:=parentdef;
  1378. end;
  1379. { get the corresponding field in the llvm shadow symtable }
  1380. llvmfield:=tabstractrecordsymtable(tabstractrecorddef(currentstructdef).symtable).llvmst[field];
  1381. if implicitpointer then
  1382. subscriptdef:=currentstructdef
  1383. else
  1384. subscriptdef:=cpointerdef.getreusable(currentstructdef);
  1385. { load the address of that shadow field }
  1386. newbase:=getaddressregister(list,cpointerdef.getreusable(llvmfield.def));
  1387. recref:=make_simple_ref(list,recref,recdef);
  1388. list.concat(taillvm.getelementptr_reg_size_ref_size_const(newbase,subscriptdef,recref,s32inttype,field.llvmfieldnr,true));
  1389. reference_reset_base(recref,subscriptdef,newbase,field.offsetfromllvmfield,recref.temppos,newalignment(recref.alignment,llvmfield.fieldoffset+field.offsetfromllvmfield),recref.volatility);
  1390. { in case of an 80 bits extended type, typecast from an array of 10
  1391. bytes (used because otherwise llvm will allocate the ABI-defined
  1392. size for extended, which is usually larger) into an extended }
  1393. if (llvmfield.def.typ=floatdef) and
  1394. (tfloatdef(llvmfield.def).floattype=s80real) then
  1395. g_ptrtypecast_ref(list,cpointerdef.getreusable(carraydef.getreusable(u8inttype,10)),cpointerdef.getreusable(s80floattype),recref);
  1396. { if it doesn't match the requested field exactly (variant record),
  1397. adjust the type of the pointer }
  1398. if (field.offsetfromllvmfield<>0) or
  1399. (llvmfield.def<>field.vardef) then
  1400. g_ptrtypecast_ref(list,cpointerdef.getreusable(llvmfield.def),cpointerdef.getreusable(field.vardef),recref);
  1401. end;
  1402. procedure thlcgllvm.a_loadmm_ref_reg(list: TAsmList; fromsize, tosize: tdef; const ref: treference; reg: tregister; shuffle: pmmshuffle);
  1403. var
  1404. href: treference;
  1405. begin
  1406. if shuffle=mms_movescalar then
  1407. a_loadfpu_ref_reg(list,fromsize,tosize,ref,reg)
  1408. else
  1409. begin
  1410. href:=make_simple_ref(list,ref,fromsize);
  1411. if ref.refaddr=addr_full then
  1412. gen_load_refaddrfull_anyreg(list,fromsize,tosize,href,reg,shuffle)
  1413. else
  1414. begin
  1415. { handle aggregate loads (happens if a struct needs to be passed
  1416. in an mmregister) }
  1417. if (fromsize.typ in [arraydef,recorddef]) or
  1418. (tosize.typ in [arraydef,recorddef]) then
  1419. begin
  1420. if handle_agg_load_ref_anyreg(list,fromsize,tosize,href,reg,mms_movescalar) then
  1421. exit;
  1422. end;
  1423. if fromsize<>tosize then
  1424. g_ptrtypecast_ref(list,cpointerdef.getreusable(fromsize),cpointerdef.getreusable(tosize),href);
  1425. { %reg = load size* %ref }
  1426. list.concat(taillvm.op_reg_size_ref(la_load,reg,cpointerdef.getreusable(tosize),href));
  1427. end;
  1428. end;
  1429. end;
  1430. procedure thlcgllvm.a_loadmm_reg_ref(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const ref: treference; shuffle: pmmshuffle);
  1431. var
  1432. href: treference;
  1433. begin
  1434. if shuffle=mms_movescalar then
  1435. a_loadfpu_reg_ref(list,fromsize,tosize,reg,ref)
  1436. else
  1437. begin
  1438. { todo }
  1439. if fromsize<>tosize then
  1440. internalerror(2013060220);
  1441. href:=make_simple_ref(list,ref,tosize);
  1442. { store tosize reg, tosize* href }
  1443. list.concat(taillvm.op_size_reg_size_ref(la_store,tosize,reg,cpointerdef.getreusable(tosize),href))
  1444. end;
  1445. end;
  1446. procedure thlcgllvm.a_loadmm_reg_reg(list: TAsmList; fromsize, tosize: tdef; reg1, reg2: tregister; shuffle: pmmshuffle);
  1447. begin
  1448. if shuffle=mms_movescalar then
  1449. a_loadfpu_reg_reg(list,fromsize,tosize,reg1,reg2)
  1450. else
  1451. { reg2 = bitcast fromllsize reg1 to tollsize }
  1452. list.concat(taillvm.op_reg_size_reg_size(la_bitcast,reg2,fromsize,reg1,tosize));
  1453. end;
  1454. procedure thlcgllvm.a_opmm_reg_reg(list: TAsmList; Op: TOpCG; size: tdef; src, dst: tregister; shuffle: pmmshuffle);
  1455. begin
  1456. if (op=OP_XOR) and
  1457. (src=dst) then
  1458. a_load_const_reg(list,size,0,dst)
  1459. else
  1460. { todo }
  1461. internalerror(2013060221);
  1462. end;
  1463. procedure thlcgllvm.a_loadmm_intreg_reg(list: TAsmList; fromsize, tosize: tdef; intreg, mmreg: tregister; shuffle: pmmshuffle);
  1464. begin
  1465. internalerror(2013060222);
  1466. end;
  1467. procedure thlcgllvm.a_loadmm_reg_intreg(list: TAsmList; fromsize, tosize: tdef; mmreg, intreg: tregister; shuffle: pmmshuffle);
  1468. begin
  1469. internalerror(2013060223);
  1470. end;
  1471. function thlcgllvm.get_call_result_cgpara(pd: tabstractprocdef; forceresdef: tdef): tcgpara;
  1472. var
  1473. paraloc: pcgparalocation;
  1474. begin
  1475. result:=inherited;
  1476. { we'll change the paraloc, make sure we don't modify the original one }
  1477. if not result.temporary then
  1478. begin
  1479. result:=result.getcopy;
  1480. result.temporary:=true;
  1481. end;
  1482. { get the LLVM representation of the function result (e.g. a
  1483. struct with two i64 fields for a record with 4 i32 fields) }
  1484. result.def:=llvmgetcgparadef(result,true,callerside);
  1485. if assigned(result.location^.next) then
  1486. begin
  1487. { unify the result into a sinlge location; unlike for parameters,
  1488. we are not responsible for splitting up results into multiple
  1489. locations }
  1490. { set the first location to the type of the function result }
  1491. result.location^.def:=result.def;
  1492. result.location^.size:=result.size;
  1493. { free all extra paralocs }
  1494. while assigned(result.location^.next) do
  1495. begin
  1496. paraloc:=result.location^.next^.next;
  1497. freemem(result.location^.next);
  1498. result.location^.next:=paraloc;
  1499. end;
  1500. end;
  1501. paraloc:=result.location;
  1502. paraloc^.def:=result.def;
  1503. case paraloc^.loc of
  1504. LOC_VOID:
  1505. ;
  1506. LOC_REGISTER,
  1507. LOC_FPUREGISTER,
  1508. LOC_MMREGISTER:
  1509. begin
  1510. paraloc^.llvmloc.loc:=paraloc^.loc;
  1511. paraloc^.llvmloc.reg:=paraloc^.register;
  1512. paraloc^.llvmvalueloc:=true;
  1513. end;
  1514. LOC_REFERENCE:
  1515. if not paramanager.ret_in_param(pd.returndef,pd) then
  1516. { TODO, if this can happen at all }
  1517. internalerror(2014011901);
  1518. else
  1519. internalerror(2014011902);
  1520. end;
  1521. end;
  1522. procedure thlcgllvm.gen_load_loc_function_result(list: TAsmList; vardef: tdef; const l: tlocation);
  1523. var
  1524. retlocpara: tcgpara;
  1525. begin
  1526. retlocpara:=get_call_result_cgpara(current_procinfo.procdef,nil);
  1527. gen_load_loc_cgpara(list,vardef,l,retlocpara);
  1528. retlocpara.resetiftemp;
  1529. end;
  1530. procedure thlcgllvm.gen_load_loc_cgpara(list: TAsmList; vardef: tdef; const l: tlocation; const cgpara: tcgpara);
  1531. var
  1532. memloc: tlocation;
  1533. begin
  1534. if not(cgpara.location^.llvmvalueloc) then
  1535. begin
  1536. memloc:=l;
  1537. location_force_mem(list,memloc,vardef);
  1538. a_loadaddr_ref_cgpara(list,vardef,memloc.reference,cgpara);
  1539. end
  1540. else
  1541. inherited;
  1542. end;
  1543. procedure thlcgllvm.gen_load_cgpara_loc(list: TAsmList; vardef: tdef; const para: TCGPara; var destloc: tlocation; reusepara: boolean);
  1544. var
  1545. ploc : pcgparalocation;
  1546. hloc : tlocation;
  1547. href, href2 : treference;
  1548. hreg : tregister;
  1549. fielddef,
  1550. llvmparadef : tdef;
  1551. index : longint;
  1552. offset : pint;
  1553. userecord : boolean;
  1554. begin
  1555. { ignore e.g. empty records }
  1556. if (para.location^.loc=LOC_VOID) then
  1557. exit;
  1558. { If the parameter location is reused we don't need to copy
  1559. anything }
  1560. if (destloc.loc=LOC_REFERENCE) and
  1561. reusepara then
  1562. exit;
  1563. { get the equivalent llvm def used to pass the parameter (e.g. a record
  1564. with two int64 fields for passing a record consisiting of 8 bytes on
  1565. x86-64) }
  1566. llvmparadef:=llvmgetcgparadef(para,true,calleeside);
  1567. userecord:=
  1568. (llvmparadef<>para.def) and
  1569. assigned(para.location^.next);
  1570. if userecord then
  1571. begin
  1572. { llvmparadef is a record in this case, with every field corresponding
  1573. to a single paraloc }
  1574. if destloc.loc<>LOC_REFERENCE then
  1575. tg.gethltemp(list,llvmparadef,llvmparadef.size,tt_normal,href)
  1576. else
  1577. begin
  1578. hreg:=getaddressregister(list,cpointerdef.getreusable(llvmparadef));
  1579. a_loadaddr_ref_reg(list,vardef,cpointerdef.getreusable(llvmparadef),destloc.reference,hreg);
  1580. reference_reset_base(href,cpointerdef.getreusable(llvmparadef),hreg,0,destloc.reference.temppos,destloc.reference.alignment,destloc.reference.volatility);
  1581. end;
  1582. index:=0;
  1583. ploc:=para.location;
  1584. repeat
  1585. paraloctoloc(ploc,hloc);
  1586. g_setup_load_field_by_name(list,trecorddef(llvmparadef),'F'+tostr(index),href,href2,fielddef);
  1587. a_load_loc_ref(list,ploc^.def,fielddef,hloc,href2);
  1588. inc(index);
  1589. ploc:=ploc^.next;
  1590. until not assigned(ploc);
  1591. if destloc.loc<>LOC_REFERENCE then
  1592. tg.ungettemp(list,href);
  1593. end
  1594. else
  1595. begin
  1596. para.check_simple_location;
  1597. paraloctoloc(para.location,hloc);
  1598. case destloc.loc of
  1599. LOC_REFERENCE :
  1600. begin
  1601. case def2regtyp(llvmparadef) of
  1602. R_INTREGISTER,
  1603. R_ADDRESSREGISTER:
  1604. a_load_loc_ref(list,llvmparadef,vardef,hloc,destloc.reference);
  1605. R_FPUREGISTER:
  1606. a_loadfpu_loc_ref(list,llvmparadef,vardef,hloc,destloc.reference);
  1607. R_MMREGISTER:
  1608. a_loadmm_loc_ref(list,llvmparadef,vardef,hloc,destloc.reference,nil);
  1609. else
  1610. internalerror(2014080801);
  1611. end;
  1612. end;
  1613. LOC_REGISTER:
  1614. begin
  1615. a_load_loc_reg(list,llvmparadef,vardef,hloc,destloc.register);
  1616. end;
  1617. LOC_FPUREGISTER:
  1618. begin
  1619. a_loadfpu_loc_reg(list,llvmparadef,vardef,hloc,destloc.register);
  1620. end;
  1621. LOC_MMREGISTER:
  1622. begin
  1623. a_loadmm_loc_reg(list,llvmparadef,vardef,hloc,destloc.register,nil);
  1624. end;
  1625. { TODO other possible locations }
  1626. else
  1627. internalerror(2013102304);
  1628. end;
  1629. end;
  1630. end;
  1631. procedure thlcgllvm.a_jmp_flags(list: TAsmList; const f: TResFlags; l: tasmlabel);
  1632. begin
  1633. internalerror(2013060224);
  1634. end;
  1635. procedure thlcgllvm.g_flags2reg(list: TAsmList; size: tdef; const f: tresflags; reg: TRegister);
  1636. begin
  1637. internalerror(2013060225);
  1638. end;
  1639. procedure thlcgllvm.g_flags2ref(list: TAsmList; size: tdef; const f: tresflags; const ref: TReference);
  1640. begin
  1641. internalerror(2013060226);
  1642. end;
  1643. procedure thlcgllvm.a_bit_scan_reg_reg(list: TAsmList; reverse: boolean; srcsize, dstsize: tdef; src, dst: tregister);
  1644. begin
  1645. internalerror(2012090201);
  1646. end;
  1647. procedure thlcgllvm.g_stackpointer_alloc(list: TAsmList; size: longint);
  1648. begin
  1649. internalerror(2012090203);
  1650. end;
  1651. procedure thlcgllvm.g_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint);
  1652. begin
  1653. internalerror(2012090204);
  1654. end;
  1655. procedure thlcgllvm.g_adjust_self_value(list: TAsmList; procdef: tprocdef; ioffset: aint);
  1656. begin
  1657. internalerror(2012090205);
  1658. end;
  1659. procedure thlcgllvm.g_local_unwind(list: TAsmList; l: TAsmLabel);
  1660. begin
  1661. internalerror(2012090206);
  1662. end;
  1663. procedure thlcgllvm.gen_stack_check_size_para(list: TAsmList);
  1664. begin
  1665. { this is implemented in a very hackish way, whereby first the call
  1666. to fpc_stackcheck() is emitted, then the prolog is generated and
  1667. registers are allocated, and finally the code to load the parameter
  1668. is inserted before the call to fpc_stackcheck(). Since parameters are
  1669. explicitly passed to call instructions for llvm, that does not work
  1670. here. It could be solved by patching the call instruction later, but
  1671. that's a lot of engineering for functionality that's only marginally
  1672. useful at best. }
  1673. end;
  1674. procedure thlcgllvm.gen_stack_check_call(list: TAsmList);
  1675. begin
  1676. { see explanation in thlcgllvm.gen_stack_check_size_para() }
  1677. end;
  1678. function thlcgllvm.make_simple_ref(list: TAsmList; const ref: treference; def: tdef): treference;
  1679. begin
  1680. result:=make_simple_ref_ptr(list,ref,cpointerdef.getreusable(def));
  1681. end;
  1682. function thlcgllvm.make_simple_ref_ptr(list: TAsmList; const ref: treference; ptrdef: tdef): treference;
  1683. var
  1684. ptrindex: tcgint;
  1685. hreg1,
  1686. hreg2: tregister;
  1687. tmpref: treference;
  1688. pointedsize: asizeint;
  1689. begin
  1690. if ref.alignment=0 then
  1691. internalerror(2016072203);
  1692. { already simple? }
  1693. if (not assigned(ref.symbol) or
  1694. (ref.base=NR_NO)) and
  1695. (ref.index=NR_NO) and
  1696. (ref.offset=0) then
  1697. begin
  1698. result:=ref;
  1699. exit;
  1700. end;
  1701. case ptrdef.typ of
  1702. pointerdef:
  1703. begin
  1704. pointedsize:=tpointerdef(ptrdef).pointeddef.size;
  1705. { void, formaldef }
  1706. if pointedsize=0 then
  1707. pointedsize:=1;
  1708. end;
  1709. else
  1710. begin
  1711. { pointedsize is only used if the offset <> 0, to see whether we
  1712. can use getelementptr if it's an exact multiple -> set pointedsize
  1713. to a value that will never be a multiple as we can't "index" other
  1714. types }
  1715. pointedsize:=ref.offset+1;
  1716. end;
  1717. end;
  1718. hreg2:=getaddressregister(list,ptrdef);
  1719. { symbol+offset or base+offset with offset a multiple of the size ->
  1720. use getelementptr }
  1721. if (ref.index=NR_NO) and
  1722. (ref.offset mod pointedsize=0) then
  1723. begin
  1724. ptrindex:=ref.offset div pointedsize;
  1725. if assigned(ref.symbol) then
  1726. reference_reset_symbol(tmpref,ref.symbol,0,ref.alignment,ref.volatility)
  1727. else
  1728. reference_reset_base(tmpref,ptrdef,ref.base,0,ref.temppos,ref.alignment,ref.volatility);
  1729. list.concat(taillvm.getelementptr_reg_size_ref_size_const(hreg2,ptrdef,tmpref,ptruinttype,ptrindex,assigned(ref.symbol)));
  1730. reference_reset_base(result,ptrdef,hreg2,0,ref.temppos,ref.alignment,ref.volatility);
  1731. exit;
  1732. end;
  1733. { for now, perform all calculations using plain pointer arithmetic. Later
  1734. we can look into optimizations based on getelementptr for structured
  1735. accesses (if only to prevent running out of virtual registers).
  1736. Assumptions:
  1737. * symbol/base register: always type "ptrdef"
  1738. * index/offset: always type "ptruinttype" (llvm bitcode has no sign information, so sign doesn't matter) }
  1739. hreg1:=getintregister(list,ptruinttype);
  1740. if assigned(ref.symbol) then
  1741. begin
  1742. if ref.base<>NR_NO then
  1743. internalerror(2012111301);
  1744. reference_reset_symbol(tmpref,ref.symbol,0,ref.alignment,ref.volatility);
  1745. list.concat(taillvm.getelementptr_reg_size_ref_size_const(hreg1,ptrdef,tmpref,ptruinttype,0,true));
  1746. end
  1747. else if ref.base<>NR_NO then
  1748. begin
  1749. a_load_reg_reg(list,ptrdef,ptruinttype,ref.base,hreg1);
  1750. end
  1751. else
  1752. { for absolute addresses }
  1753. a_load_const_reg(list,ptruinttype,0,hreg1);
  1754. if ref.index<>NR_NO then
  1755. begin
  1756. { SSA... }
  1757. hreg2:=getintregister(list,ptruinttype);
  1758. a_op_reg_reg_reg(list,OP_ADD,ptruinttype,ref.index,hreg1,hreg2);
  1759. hreg1:=hreg2;
  1760. end;
  1761. if ref.offset<>0 then
  1762. begin
  1763. hreg2:=getintregister(list,ptruinttype);
  1764. a_op_const_reg_reg(list,OP_ADD,ptruinttype,ref.offset,hreg1,hreg2);
  1765. hreg1:=hreg2;
  1766. end;
  1767. hreg2:=getaddressregister(list,ptrdef);
  1768. a_load_reg_reg(list,ptruinttype,ptrdef,hreg1,hreg2);
  1769. reference_reset_base(result,ptrdef,hreg2,0,ref.temppos,ref.alignment,ref.volatility);
  1770. end;
  1771. procedure thlcgllvm.set_call_function_result(const list: TAsmList; const pd: tabstractprocdef; const llvmretdef, hlretdef: tdef; const resval: tregister; var retpara: tcgpara);
  1772. var
  1773. hreg: tregister;
  1774. rettemp: treference;
  1775. begin
  1776. if (not is_void(hlretdef) and
  1777. not paramanager.ret_in_param(hlretdef, pd)) or
  1778. pd.generate_safecall_wrapper then
  1779. begin
  1780. { should already be a copy, because it currently describes the llvm
  1781. return location }
  1782. if not retpara.temporary then
  1783. internalerror(2014020101);
  1784. if llvmaggregatetype(hlretdef) then
  1785. begin
  1786. { to ease the handling of aggregate types here, we just store
  1787. everything to memory rather than potentially dealing with aggregates
  1788. in "registers" }
  1789. tg.gethltemp(list, llvmretdef, llvmretdef.size, tt_normal, rettemp);
  1790. case def2regtyp(llvmretdef) of
  1791. R_INTREGISTER,
  1792. R_ADDRESSREGISTER:
  1793. a_load_reg_ref(list,llvmretdef,llvmretdef,resval,rettemp);
  1794. R_FPUREGISTER:
  1795. a_loadfpu_reg_ref(list,llvmretdef,llvmretdef,resval,rettemp);
  1796. R_MMREGISTER:
  1797. a_loadmm_reg_ref(list,llvmretdef,llvmretdef,resval,rettemp,mms_movescalar);
  1798. else
  1799. ;
  1800. end;
  1801. { the return parameter now contains a value whose type matches the one
  1802. that the high level code generator expects instead of the llvm shim
  1803. }
  1804. retpara.def:=llvmretdef;
  1805. retpara.location^.def:=llvmretdef;
  1806. { for llvm-specific code: }
  1807. retpara.location^.llvmvalueloc:=false;
  1808. retpara.location^.llvmloc.loc:=LOC_REGISTER;
  1809. retpara.location^.llvmloc.reg:=rettemp.base;
  1810. { for the rest (normally not used, but cleaner to set it correclty) }
  1811. retpara.location^.loc:=LOC_REFERENCE;
  1812. retpara.location^.reference.index:=rettemp.base;
  1813. retpara.location^.reference.offset:=0;
  1814. end
  1815. else
  1816. begin
  1817. retpara.def:=llvmretdef;
  1818. retpara.Location^.def:=llvmretdef;
  1819. retpara.location^.llvmloc.reg:=resval;
  1820. retpara.Location^.llvmloc.loc:=retpara.location^.loc;
  1821. retpara.Location^.llvmvalueloc:=true;
  1822. end;
  1823. end
  1824. else
  1825. retpara.location^.llvmloc.loc:=LOC_VOID;
  1826. end;
  1827. procedure thlcgllvm.paraloctoloc(const paraloc: pcgparalocation; out hloc: tlocation);
  1828. begin
  1829. case paraloc^.llvmloc.loc of
  1830. LOC_REFERENCE:
  1831. begin
  1832. location_reset_ref(hloc,LOC_REFERENCE,def_cgsize(paraloc^.def),paraloc^.def.alignment,[]);
  1833. hloc.reference.symbol:=paraloc^.llvmloc.sym;
  1834. if paraloc^.llvmvalueloc then
  1835. hloc.reference.refaddr:=addr_full;
  1836. end;
  1837. LOC_REGISTER:
  1838. begin
  1839. if paraloc^.llvmvalueloc then
  1840. begin
  1841. location_reset(hloc,LOC_REGISTER,def_cgsize(paraloc^.def));
  1842. hloc.register:=paraloc^.llvmloc.reg;
  1843. end
  1844. else
  1845. begin
  1846. if getregtype(paraloc^.llvmloc.reg)<>R_TEMPREGISTER then
  1847. internalerror(2014011903);
  1848. location_reset_ref(hloc,LOC_REFERENCE,def_cgsize(paraloc^.def),paraloc^.def.alignment,[]);
  1849. hloc.reference.base:=paraloc^.llvmloc.reg;
  1850. end;
  1851. end;
  1852. LOC_FPUREGISTER,
  1853. LOC_MMREGISTER:
  1854. begin
  1855. if paraloc^.llvmvalueloc then
  1856. begin
  1857. location_reset(hloc,paraloc^.llvmloc.loc,def_cgsize(paraloc^.def));
  1858. hloc.register:=paraloc^.llvmloc.reg;
  1859. end
  1860. else
  1861. internalerror(2014012401);
  1862. end
  1863. else
  1864. internalerror(2014010706);
  1865. end;
  1866. end;
  1867. procedure thlcgllvm.varsym_set_localloc(list: TAsmList; vs: tabstractnormalvarsym);
  1868. begin
  1869. if cs_asm_source in current_settings.globalswitches then
  1870. begin
  1871. case vs.initialloc.loc of
  1872. LOC_REFERENCE :
  1873. begin
  1874. if assigned(vs.initialloc.reference.symbol) then
  1875. list.concat(Tai_comment.Create(strpnew('Var '+vs.realname+' located at '+
  1876. vs.initialloc.reference.symbol.name)))
  1877. else
  1878. list.concat(Tai_comment.Create(strpnew('Var '+vs.realname+' located at %tmp.'+
  1879. tostr(getsupreg(vs.initialloc.reference.base)))));
  1880. end;
  1881. else
  1882. ;
  1883. end;
  1884. end;
  1885. vs.localloc:=vs.initialloc;
  1886. end;
  1887. procedure thlcgllvm.paravarsym_set_initialloc_to_paraloc(vs: tparavarsym);
  1888. var
  1889. parasym : tasmsymbol;
  1890. begin
  1891. if vs.paraloc[calleeside].location^.llvmloc.loc<>LOC_REFERENCE then
  1892. internalerror(2014010708);
  1893. parasym:=vs.paraloc[calleeside].location^.llvmloc.sym;
  1894. reference_reset_symbol(vs.initialloc.reference,parasym,0,vs.paraloc[calleeside].alignment,[]);
  1895. if vs.paraloc[calleeside].location^.llvmvalueloc then
  1896. vs.initialloc.reference.refaddr:=addr_full;
  1897. end;
  1898. procedure thlcgllvm.g_external_wrapper(list: TAsmList; procdef: tprocdef; const wrappername, externalname: string; global: boolean);
  1899. var
  1900. asmsym: TAsmSymbol;
  1901. begin
  1902. if po_external in procdef.procoptions then
  1903. exit;
  1904. asmsym:=current_asmdata.RefAsmSymbol(externalname,AT_FUNCTION);
  1905. list.concat(taillvmalias.create(asmsym,wrappername,procdef,asmsym.bind));
  1906. end;
  1907. procedure create_hlcodegen_llvm;
  1908. begin
  1909. if not assigned(current_procinfo) or
  1910. not(po_assembler in current_procinfo.procdef.procoptions) then
  1911. begin
  1912. tgobjclass:=ttgllvm;
  1913. hlcg:=thlcgllvm.create;
  1914. cgllvm.create_codegen
  1915. end
  1916. else
  1917. begin
  1918. tgobjclass:=orgtgclass;
  1919. create_hlcodegen_cpu;
  1920. { todo: handle/remove chlcgobj }
  1921. end;
  1922. end;
  1923. begin
  1924. chlcgobj:=thlcgllvm;
  1925. { this unit must initialise after hlcgobj;
  1926. message system has not been initialised yet here }
  1927. if not assigned(create_hlcodegen) then
  1928. begin
  1929. writeln('Internalerror 2018052003');
  1930. halt(1);
  1931. end;
  1932. create_hlcodegen_cpu:=create_hlcodegen;
  1933. create_hlcodegen:=@create_hlcodegen_llvm;
  1934. end.