hlcgllvm.pas 81 KB

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