hlcgllvm.pas 74 KB

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