aasmllvm.pas 38 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258
  1. {
  2. Copyright (c) 2010, 2013 by Jonas Maebe
  3. Contains the assembler object for the LLVM target
  4. This program is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation; either version 2 of the License, or
  7. (at your option) any later version.
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. GNU General Public License for more details.
  12. You should have received a copy of the GNU General Public License
  13. along with this program; if not, write to the Free Software
  14. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  15. ****************************************************************************
  16. }
  17. unit aasmllvm;
  18. {$i fpcdefs.inc}
  19. interface
  20. uses
  21. globtype,verbose,cclasses,
  22. aasmbase,aasmtai,aasmdata,aasmsym,aasmcnst,
  23. cpubase,cgbase,cgutils,
  24. symtype,symdef,symsym,
  25. llvmbase;
  26. type
  27. { taillvm }
  28. taillvm = class(tai_cpu_abstract_sym)
  29. llvmopcode: tllvmop;
  30. metadata: tai;
  31. constructor create_llvm(op: tllvmop);
  32. destructor Destroy; override;
  33. { e.g. unreachable }
  34. constructor op_none(op : tllvmop);
  35. { e.g. ret void }
  36. constructor op_size(op : tllvmop; size: tdef);
  37. { e.g. dst = alloca size }
  38. constructor op_reg_size(op:tllvmop;dst:tregister;size:tdef);
  39. { e.g. dst = alloca size }
  40. constructor op_ref_size(op:tllvmop;const dst:treference;size:tdef);
  41. { e.g. dst = add size src1, src2 }
  42. constructor op_reg_size_reg_reg(op:tllvmop;dst:tregister;size:tdef;src1,src2:tregister);
  43. { e.g. dst = shl size src1, 1 ( = src1 shl 1) }
  44. constructor op_reg_size_reg_const(op:tllvmop;dst:tregister;size:tdef;src1:tregister;src2:int64);
  45. { e.g. dst = sub size 0, src2 ( = 0 - src2) }
  46. constructor op_reg_size_const_reg(op:tllvmop;dst:tregister;size:tdef;src1:int64;src2:tregister);
  47. { e.g. dst = bitcast size1 src to tosize }
  48. constructor op_reg_size_reg_size(op:tllvmop;dst:tregister;fromsize:tdef;src:tregister;tosize:tdef);
  49. { e.g. dst = bitcast fromsize 255 to tosize }
  50. constructor op_reg_size_const_size(op:tllvmop;dst:tregister;fromsize:tdef;src:int64;tosize:tdef);
  51. { e.g. dst = bitcast fromsize double to tosize }
  52. constructor op_reg_size_fpconst_size(op:tllvmop;dst:tregister;fromsize:tdef;src:double;tosize:tdef);
  53. {$ifdef cpuextended}
  54. { e.g. dst = bitcast fromsize extended to tosize }
  55. constructor op_reg_size_fpconst80_size(op:tllvmop;dst:tregister;fromsize:tdef;src:extended;tosize:tdef);
  56. {$endif cpuextended}
  57. { e.g. dst = bitcast fromsize @globalvar to tosize }
  58. constructor op_reg_size_sym_size(op:tllvmop;dst:tregister;fromsize:tdef;src:TAsmSymbol;tosize:tdef);
  59. { e.g. dst = bitcast fromsize <abstracttaidata> to tosize }
  60. constructor op_reg_tai_size(op:tllvmop;dst:tregister;src:tai;tosize:tdef);
  61. { dst = bitcast size undef to size }
  62. constructor op_reg_size_undef(op: tllvmop; dst: tregister; size: tdef);
  63. { return size undef }
  64. constructor op_size_undef(op: tllvmop; size: tdef);
  65. { e.g. dst = bitcast fromsize src to tosize }
  66. constructor op_reg_size_ref_size(op:tllvmop;dst:tregister;fromsize:tdef;const src:treference;tosize:tdef);
  67. { e.g. store fromsize src, ptrsize toref}
  68. constructor op_size_reg_size_ref(op:tllvmop;fromsize:tdef;src:tregister;ptrsize:tdef;const toref:treference);
  69. { e.g. store fromsize srcref, ptrsize toref (with srcref.refaddr=full) }
  70. constructor op_size_ref_size_ref(op:tllvmop;fromsize:tdef;const src:treference;ptrsize:tdef;const toref:treference);
  71. { e.g. store fromsize const, ptrsize toref}
  72. constructor op_size_const_size_ref(op:tllvmop;fromsize:tdef;src:int64;ptrsize:tdef;const toref:treference);
  73. { e.g. dst = load fromsize fromref }
  74. constructor op_reg_size_ref(op:tllvmop;dst:tregister;fromsize:tdef;const fromref:treference);
  75. { e.g. dst = icmp cmpcond size reg1, reg2 }
  76. constructor op_reg_cond_size_reg_reg(op:tllvmop;dst:tregister;cmpcond:topcmp;size:tdef;reg1,reg2:tregister);
  77. { e.g. dst = icmp cmpcond size reg1, constant }
  78. constructor op_reg_cond_size_reg_const(op:tllvmop;dst:tregister;cmpcond:topcmp;size:tdef;reg1:tregister;cnst:int64);
  79. { e.g. dst = fcmp cmpcond size reg1, reg2 }
  80. constructor op_reg_fpcond_size_reg_reg(op:tllvmop;dst:tregister;cmpcond:tllvmfpcmp;size:tdef;reg1,reg2:tregister);
  81. { e.g. br label lab }
  82. constructor op_lab(op:tllvmop;lab:tasmlabel);
  83. { e.g. br i1 condreg, label iftrue, label iffalse }
  84. constructor op_size_reg_lab_lab(op:tllvmop;fromsize:tdef;condreg:tregister;labtrue,labfalse: tasmlabel);
  85. { e.g. la_ret retdef retval }
  86. constructor op_size_reg(op:tllvmop;def: tdef;reg: tregister);
  87. { e.g. dst = getelementptr ptrsize ref, i32 0 (if indirect), index1type index1 }
  88. constructor getelementptr_reg_size_ref_size_reg(dst:tregister;ptrsize:tdef;const ref:treference;indextype:tdef;index1:tregister;indirect:boolean);
  89. constructor getelementptr_reg_size_ref_size_const(dst:tregister;ptrsize:tdef;const ref:treference;indextype:tdef;index1:ptrint;indirect:boolean);
  90. constructor getelementptr_reg_tai_size_const(dst:tregister;const ai:tai;indextype:tdef;index1:ptrint;indirect:boolean);
  91. constructor blockaddress(size: tdef; fun, lab: tasmsymbol);
  92. constructor landingpad(dst:tregister;def:tdef;firstclause:taillvm);
  93. constructor exceptclause(op:tllvmop;def:tdef;kind:TAsmSymbol;nextclause:taillvm);
  94. constructor cleanupclause;
  95. { e.g. dst = call retsize name (paras) }
  96. constructor call_size_name_paras(callpd: tdef;cc: tproccalloption;dst: tregister;retsize: tdef;name:tasmsymbol;paras: tfplist);
  97. { e.g. dst = call retsize reg (paras) }
  98. constructor call_size_reg_paras(callpd: tdef; cc: tproccalloption; dst: tregister;retsize: tdef;reg:tregister;paras: tfplist);
  99. { e.g. dst = invoke retsize name (paras) to label <normal label> unwind label <exception label> }
  100. constructor invoke_size_name_paras_retlab_exceptlab(callpd: tdef; cc: tproccalloption; dst: tregister; retsize: tdef;name: tasmsymbol; paras: tfplist; retlab, exceptlab:TAsmLabel);
  101. { e.g. dst = invoke retsize reg (paras) to label <normal label> unwind label <exception label> }
  102. constructor invoke_size_reg_paras_retlab_exceptlab(callpd: tdef; cc: tproccalloption; dst: tregister; retsize: tdef; reg: tregister; paras: tfplist; retlab, exceptlab:TAsmLabel);
  103. { e.g. dst := extractvalue srcsize src, 0 (note: no type for the index) }
  104. constructor extract(op: tllvmop; dst: tregister; srcsize: tdef; src: tregister; idx: longint);
  105. { inline function-level assembler code and parameters }
  106. constructor asm_paras(asmlist: tasmlist; paras: tfplist);
  107. procedure loadoper(opidx: longint; o: toper); override;
  108. procedure clearop(opidx: longint); override;
  109. procedure loadtai(opidx: longint; _ai: tai);
  110. procedure loaddef(opidx: longint; _def: tdef);
  111. procedure loadundef(opidx: longint);
  112. procedure loadsingle(opidx: longint; _sval: single);
  113. procedure loaddouble(opidx: longint; _dval: double);
  114. {$ifdef cpuextended}
  115. procedure loadextended(opidx: longint; _eval: extended);
  116. {$endif cpuextended}
  117. procedure loadcond(opidx: longint; _cond: topcmp);
  118. procedure loadfpcond(opidx: longint; _fpcond: tllvmfpcmp);
  119. procedure loadparas(opidx: longint; _paras: tfplist);
  120. procedure loadasmlist(opidx: longint; _asmlist: tasmlist);
  121. procedure loadcallingconvention(opidx: longint; calloption: tproccalloption);
  122. procedure addinsmetadata(insmeta: tai);
  123. procedure landingpad_add_clause(op: tllvmop; def: tdef; kind: TAsmSymbol);
  124. { register spilling code }
  125. function spilling_get_operation_type(opnr: longint): topertype;override;
  126. function spilling_get_reg_type(opnr: longint): tdef;
  127. end;
  128. tllvmvisibility = (llv_default, llv_hidden, llv_protected);
  129. tllvmlinkage = (
  130. { llvm 2.5 }
  131. lll_default { = externally visible/global },
  132. lll_private, lll_internal, lll_linkonce, lll_common,
  133. lll_weak, lll_appending, lll_extern_weak,
  134. lll_dllimport, lll_dllexport,
  135. { llvm 2.6+ }
  136. lll_linker_private, lll_private_weak, lll_private_weak_def_auto,
  137. lll_available_externally,lll_linkonce_odr, lll_weak_odr
  138. );
  139. taillvmalias = class(tailineinfo)
  140. bind: tasmsymbind;
  141. oldsym, newsym: TAsmSymbol;
  142. def: tdef;
  143. constructor create(_oldsym: tasmsymbol; const newname: TSymStr; _def: tdef; _bind: tasmsymbind);
  144. end;
  145. taillvmdeclflag =
  146. (
  147. ldf_definition, { definition as opposed to (an external) declaration }
  148. ldf_tls, { tls definition }
  149. ldf_unnamed_addr, { address doesn't matter, only content }
  150. ldf_vectorized, { vectorized, dead-strippable data }
  151. ldf_weak, { weak definition }
  152. ldf_appending { appending linkage definition }
  153. );
  154. taillvmdeclflags = set of taillvmdeclflag;
  155. { declarations/definitions of symbols (procedures, variables), both defined
  156. here and external }
  157. taillvmdecl = class(tai)
  158. { initialisation data, if any }
  159. initdata: tasmlist;
  160. namesym: tasmsymbol;
  161. def: tdef;
  162. sec: TAsmSectiontype;
  163. alignment: shortint;
  164. flags: taillvmdeclflags;
  165. secname: TSymStr;
  166. metadata: tai;
  167. constructor createdecl(_namesym: tasmsymbol; _def: tdef; _initdata: tasmlist; _sec: tasmsectiontype; _alignment: shortint);
  168. constructor createdef(_namesym: tasmsymbol; _def: tdef; _initdata: tasmlist; _sec: tasmsectiontype; _alignment: shortint);
  169. constructor createtls(_namesym: tasmsymbol; _def: tdef; _alignment: shortint);
  170. procedure setsecname(const name: TSymStr);
  171. procedure addinsmetadata(insmeta: tai);
  172. destructor destroy; override;
  173. end;
  174. { parameter to an llvm call instruction }
  175. pllvmcallpara = ^tllvmcallpara;
  176. tllvmcallpara = record
  177. def: tdef;
  178. alignment: shortint;
  179. valueext: tllvmvalueextension;
  180. byval,
  181. sret: boolean;
  182. case typ: toptype of
  183. top_none: ();
  184. top_reg: (register: tregister);
  185. top_ref: (sym: tasmsymbol);
  186. top_const: (value: int64);
  187. top_undef : ();
  188. top_tai : (ai: tai);
  189. end;
  190. implementation
  191. uses
  192. cutils, strings,
  193. symconst,
  194. aasmcpu;
  195. { taillvmprocdecl }
  196. constructor taillvmdecl.createdecl(_namesym: tasmsymbol; _def: tdef; _initdata: tasmlist; _sec: tasmsectiontype; _alignment: shortint);
  197. begin
  198. inherited create;
  199. typ:=ait_llvmdecl;
  200. namesym:=_namesym;
  201. def:=_def;
  202. initdata:=_initdata;
  203. sec:=_sec;
  204. alignment:=_alignment;
  205. _namesym.declared:=true;
  206. flags:=[];
  207. end;
  208. constructor taillvmdecl.createdef(_namesym: tasmsymbol; _def: tdef; _initdata: tasmlist; _sec: tasmsectiontype; _alignment: shortint);
  209. begin
  210. createdecl(_namesym,_def,_initdata,_sec,_alignment);
  211. include(flags,ldf_definition);
  212. end;
  213. constructor taillvmdecl.createtls(_namesym: tasmsymbol; _def: tdef; _alignment: shortint);
  214. begin
  215. createdef(_namesym,_def,nil,sec_data,_alignment);
  216. include(flags,ldf_tls);
  217. end;
  218. procedure taillvmdecl.setsecname(const name: TSymStr);
  219. begin
  220. if sec<>sec_user then
  221. internalerror(2015111501);
  222. secname:=name;
  223. end;
  224. procedure taillvmdecl.addinsmetadata(insmeta: tai);
  225. begin
  226. insmeta.next:=metadata;
  227. metadata:=insmeta;
  228. end;
  229. destructor taillvmdecl.destroy;
  230. var
  231. hp: tai;
  232. begin
  233. while assigned(metadata) do
  234. begin
  235. hp:=tai(metadata.next);
  236. metadata.free;
  237. metadata:=hp;
  238. end;
  239. initdata.free;
  240. inherited destroy;
  241. end;
  242. { taillvmalias }
  243. constructor taillvmalias.create(_oldsym: tasmsymbol; const newname: TSymStr; _def: tdef; _bind: tasmsymbind);
  244. begin
  245. inherited Create;
  246. typ:=ait_llvmalias;
  247. oldsym:=_oldsym;
  248. newsym:=current_asmdata.DefineAsmSymbol(newname,AB_GLOBAL,AT_FUNCTION,_def);
  249. newsym.declared:=true;
  250. def:=_def;
  251. { alias cannot be external }
  252. case _bind of
  253. { weak external should actually become weak, but we don't support that
  254. yet }
  255. AB_WEAK_EXTERNAL:
  256. internalerror(2016071203);
  257. AB_EXTERNAL:
  258. _bind:=AB_GLOBAL;
  259. AB_EXTERNAL_INDIRECT:
  260. _bind:=AB_INDIRECT;
  261. else
  262. ;
  263. end;
  264. bind:=_bind;
  265. end;
  266. {*****************************************************************************
  267. taicpu Constructors
  268. *****************************************************************************}
  269. constructor taillvm.create_llvm(op: tllvmop);
  270. begin
  271. create(a_none);
  272. llvmopcode:=op;
  273. typ:=ait_llvmins;
  274. end;
  275. destructor taillvm.Destroy;
  276. var
  277. hp: tai;
  278. begin
  279. while assigned(metadata) do
  280. begin
  281. hp:=tai(metadata.next);
  282. metadata.free;
  283. metadata:=hp;
  284. end;
  285. inherited;
  286. end;
  287. procedure taillvm.loadoper(opidx: longint; o: toper);
  288. var
  289. i: longint;
  290. callpara: pllvmcallpara;
  291. begin
  292. inherited;
  293. if o.typ=top_para then
  294. begin
  295. oper[opidx]^.paras:=tfplist.create;
  296. for i:=0 to o.paras.count-1 do
  297. begin
  298. new(callpara);
  299. callpara^:=pllvmcallpara(o.paras[i])^;
  300. oper[opidx]^.paras.add(callpara);
  301. if (callpara^.typ = top_reg) and
  302. assigned(add_reg_instruction_hook) then
  303. add_reg_instruction_hook(self,callpara^.register);
  304. end;
  305. end;
  306. end;
  307. procedure taillvm.clearop(opidx: longint);
  308. var
  309. callpara: pllvmcallpara;
  310. i: longint;
  311. begin
  312. case oper[opidx]^.typ of
  313. top_para:
  314. begin
  315. for i:=0 to oper[opidx]^.paras.count-1 do
  316. begin
  317. callpara:=pllvmcallpara(oper[opidx]^.paras[i]);
  318. case callpara^.typ of
  319. top_tai:
  320. callpara^.ai.free;
  321. else
  322. ;
  323. end;
  324. dispose(callpara);
  325. end;
  326. oper[opidx]^.paras.free;
  327. end;
  328. top_tai:
  329. oper[opidx]^.ai.free;
  330. top_asmlist:
  331. oper[opidx]^.asmlist.free;
  332. else
  333. ;
  334. end;
  335. inherited;
  336. end;
  337. procedure taillvm.loadtai(opidx: longint; _ai: tai);
  338. begin
  339. allocate_oper(opidx+1);
  340. with oper[opidx]^ do
  341. begin
  342. clearop(opidx);
  343. ai:=_ai;
  344. typ:=top_tai;
  345. end;
  346. end;
  347. procedure taillvm.loaddef(opidx:longint;_def: tdef);
  348. begin
  349. allocate_oper(opidx+1);
  350. with oper[opidx]^ do
  351. begin
  352. if typ<>top_def then
  353. clearop(opidx);
  354. def:=_def;
  355. typ:=top_def;
  356. end;
  357. end;
  358. procedure taillvm.loadundef(opidx: longint);
  359. begin
  360. allocate_oper(opidx+1);
  361. with oper[opidx]^ do
  362. typ:=top_undef
  363. end;
  364. procedure taillvm.loadsingle(opidx: longint; _sval: single);
  365. begin
  366. allocate_oper(opidx+1);
  367. with oper[opidx]^ do
  368. begin
  369. if typ<>top_single then
  370. clearop(opidx);
  371. sval:=_sval;
  372. typ:=top_single;
  373. end;
  374. end;
  375. procedure taillvm.loaddouble(opidx: longint; _dval: double);
  376. begin
  377. allocate_oper(opidx+1);
  378. with oper[opidx]^ do
  379. begin
  380. if typ<>top_double then
  381. clearop(opidx);
  382. dval:=_dval;
  383. typ:=top_double;
  384. end;
  385. end;
  386. {$ifdef cpuextended}
  387. procedure taillvm.loadextended(opidx: longint; _eval: extended);
  388. begin
  389. allocate_oper(opidx+1);
  390. with oper[opidx]^ do
  391. begin
  392. if typ<>top_extended80 then
  393. clearop(opidx);
  394. eval:=_eval;
  395. typ:=top_extended80;
  396. end;
  397. end;
  398. {$endif cpuextended}
  399. procedure taillvm.loadcond(opidx: longint; _cond: topcmp);
  400. begin
  401. allocate_oper(opidx+1);
  402. with oper[opidx]^ do
  403. begin
  404. if typ<>top_cond then
  405. clearop(opidx);
  406. cond:=_cond;
  407. typ:=top_cond;
  408. end;
  409. end;
  410. procedure taillvm.loadfpcond(opidx: longint; _fpcond: tllvmfpcmp);
  411. begin
  412. allocate_oper(opidx+1);
  413. with oper[opidx]^ do
  414. begin
  415. if typ<>top_fpcond then
  416. clearop(opidx);
  417. fpcond:=_fpcond;
  418. typ:=top_fpcond;
  419. end;
  420. end;
  421. procedure taillvm.loadparas(opidx: longint; _paras: tfplist);
  422. var
  423. callpara: pllvmcallpara;
  424. i: longint;
  425. begin
  426. allocate_oper(opidx+1);
  427. with oper[opidx]^ do
  428. begin
  429. clearop(opidx);
  430. paras:=_paras;
  431. for i:=0 to _paras.count-1 do
  432. begin
  433. callpara:=pllvmcallpara(_paras[i]);
  434. if (callpara^.typ=top_reg) and
  435. assigned(add_reg_instruction_hook) then
  436. add_reg_instruction_hook(self,callpara^.register);
  437. end;
  438. typ:=top_para;
  439. end;
  440. end;
  441. procedure taillvm.loadasmlist(opidx: longint; _asmlist: tasmlist);
  442. begin
  443. allocate_oper(opidx+1);
  444. with oper[opidx]^ do
  445. begin
  446. clearop(opidx);
  447. asmlist:=_asmlist;
  448. typ:=top_asmlist;
  449. end;
  450. end;
  451. procedure taillvm.loadcallingconvention(opidx: longint; calloption: tproccalloption);
  452. begin
  453. allocate_oper(opidx+1);
  454. with oper[opidx]^ do
  455. begin
  456. clearop(opidx);
  457. callingconvention:=calloption;
  458. typ:=top_callingconvention;
  459. end;
  460. end;
  461. procedure taillvm.addinsmetadata(insmeta: tai);
  462. begin
  463. insmeta.next:=metadata;
  464. metadata:=insmeta;
  465. end;
  466. procedure taillvm.landingpad_add_clause(op: tllvmop; def: tdef; kind: TAsmSymbol);
  467. var
  468. lastclause,
  469. clause: taillvm;
  470. begin
  471. if llvmopcode<>la_landingpad then
  472. internalerror(2018052001);
  473. if op<>la_cleanup then
  474. clause:=taillvm.exceptclause(op,def,kind,nil)
  475. else
  476. clause:=taillvm.cleanupclause;
  477. lastclause:=self;
  478. while assigned(lastclause.oper[2]^.ai) do
  479. lastclause:=taillvm(lastclause.oper[2]^.ai);
  480. lastclause.loadtai(2,clause);
  481. end;
  482. function taillvm.spilling_get_operation_type(opnr: longint): topertype;
  483. begin
  484. case llvmopcode of
  485. la_ret, la_br, la_switch, la_indirectbr,
  486. la_resume,
  487. la_unreachable,
  488. la_store,
  489. la_fence,
  490. la_cmpxchg,
  491. la_atomicrmw:
  492. begin
  493. { instructions that never have a result }
  494. result:=operand_read;
  495. end;
  496. la_alloca,
  497. la_trunc, la_zext, la_sext, la_fptrunc, la_fpext,
  498. la_fptoui, la_fptosi, la_uitofp, la_sitofp,
  499. la_ptrtoint, la_inttoptr,
  500. la_bitcast,
  501. la_add, la_fadd, la_sub, la_fsub, la_mul, la_fmul,
  502. la_udiv,la_sdiv, la_fdiv, la_urem, la_srem, la_frem,
  503. la_shl, la_lshr, la_ashr, la_and, la_or, la_xor,
  504. la_extractelement, la_insertelement, la_shufflevector,
  505. la_extractvalue, la_insertvalue,
  506. la_getelementptr,
  507. la_load,
  508. la_icmp, la_fcmp,
  509. la_phi, la_select,
  510. la_va_arg, la_landingpad:
  511. begin
  512. if opnr=0 then
  513. result:=operand_write
  514. else
  515. result:=operand_read;
  516. end;
  517. la_invoke, la_call:
  518. begin
  519. if opnr=1 then
  520. result:=operand_write
  521. else
  522. result:=operand_read;
  523. end;
  524. la_blockaddress:
  525. case opnr of
  526. 1: result:=operand_write
  527. else
  528. result:=operand_read;
  529. end
  530. else
  531. internalerror(2013103101)
  532. end;
  533. end;
  534. function taillvm.spilling_get_reg_type(opnr: longint): tdef;
  535. begin
  536. case llvmopcode of
  537. la_trunc, la_zext, la_sext, la_fptrunc, la_fpext,
  538. la_fptoui, la_fptosi, la_uitofp, la_sitofp,
  539. la_ptrtoint, la_inttoptr,
  540. la_bitcast:
  541. begin
  542. { toreg = bitcast fromsize fromreg to tosize }
  543. case opnr of
  544. 0: result:=oper[3]^.def;
  545. 2: result:=oper[1]^.def
  546. else
  547. internalerror(2013103102);
  548. end;
  549. end;
  550. la_ret, la_switch, la_indirectbr,
  551. la_resume, la_catch:
  552. begin
  553. { ret size reg }
  554. if opnr=1 then
  555. result:=oper[0]^.def
  556. else
  557. internalerror(2013110101);
  558. end;
  559. la_invoke, la_call:
  560. begin
  561. case opnr of
  562. 1: result:=oper[0]^.def;
  563. 4:
  564. begin
  565. if oper[4]^.typ=top_reg then
  566. result:=oper[3]^.def
  567. else
  568. internalerror(2015112001)
  569. end
  570. else
  571. internalerror(2013110102);
  572. end;
  573. end;
  574. la_br,
  575. la_unreachable:
  576. internalerror(2013110103);
  577. la_store:
  578. begin
  579. case opnr of
  580. 1: result:=oper[0]^.def;
  581. { type of the register in the reference }
  582. 3: result:=oper[2]^.def;
  583. else
  584. internalerror(2013110104);
  585. end;
  586. end;
  587. la_load:
  588. begin
  589. { dst = load ptrdef srcref }
  590. case opnr of
  591. 0: result:=tpointerdef(oper[1]^.def).pointeddef;
  592. 2: result:=oper[1]^.def;
  593. else
  594. internalerror(2013110105);
  595. end;
  596. end;
  597. la_getelementptr:
  598. begin
  599. { dst = getelementptr ref ... }
  600. case opnr of
  601. 0:
  602. begin
  603. case oper[1]^.typ of
  604. top_def:
  605. result:=oper[1]^.def;
  606. top_tai:
  607. begin
  608. case oper[1]^.ai.typ of
  609. ait_llvmins:
  610. result:=taillvm(oper[1]^.ai).spilling_get_reg_type(0);
  611. ait_typedconst:
  612. result:=tai_abstracttypedconst(oper[1]^.ai).def
  613. else
  614. internalerror(2016071202);
  615. end
  616. end
  617. else
  618. internalerror(2016071201);
  619. end
  620. end;
  621. 2:
  622. result:=oper[1]^.def;
  623. else
  624. internalerror(2013110111);
  625. end;
  626. end;
  627. la_fence,
  628. la_cmpxchg,
  629. la_atomicrmw:
  630. begin
  631. internalerror(2013110610);
  632. end;
  633. la_add, la_fadd, la_sub, la_fsub, la_mul, la_fmul,
  634. la_udiv,la_sdiv, la_fdiv, la_urem, la_srem, la_frem,
  635. la_shl, la_lshr, la_ashr, la_and, la_or, la_xor:
  636. begin
  637. case opnr of
  638. 0,2,3:
  639. result:=oper[1]^.def;
  640. else
  641. internalerror(2013110106);
  642. end;
  643. end;
  644. la_extractelement, la_insertelement, la_shufflevector,
  645. la_extractvalue:
  646. begin
  647. { todo }
  648. internalerror(2013110107);
  649. end;
  650. la_insertvalue:
  651. begin
  652. case opnr of
  653. 0,2: result:=oper[1]^.def;
  654. else
  655. internalerror(2013110108);
  656. end;
  657. end;
  658. la_icmp, la_fcmp:
  659. begin
  660. case opnr of
  661. 0: result:=llvmbool1type;
  662. 3,4: result:=oper[2]^.def;
  663. else
  664. internalerror(2013110801);
  665. end
  666. end;
  667. la_alloca:
  668. begin
  669. { shouldn't be spilled, the result of alloca should be read-only }
  670. internalerror(2013110109);
  671. end;
  672. la_select:
  673. begin
  674. case opnr of
  675. 0,4,6: result:=oper[3]^.def;
  676. 2: result:=oper[1]^.def;
  677. else
  678. internalerror(2013110110);
  679. end;
  680. end;
  681. la_blockaddress:
  682. case opnr of
  683. 1: result:=voidcodepointertype
  684. else
  685. internalerror(2015111904);
  686. end
  687. else
  688. internalerror(2013103103)
  689. end;
  690. end;
  691. constructor taillvm.op_none(op: tllvmop);
  692. begin
  693. create_llvm(op);
  694. ops:=0;
  695. end;
  696. constructor taillvm.op_size(op : tllvmop; size: tdef);
  697. begin
  698. create_llvm(op);
  699. ops:=1;
  700. loaddef(0,size);
  701. end;
  702. constructor taillvm.op_reg_size(op: tllvmop; dst: tregister; size: tdef);
  703. begin
  704. create_llvm(op);
  705. ops:=2;
  706. loadreg(0,dst);
  707. loaddef(1,size);
  708. end;
  709. constructor taillvm.op_ref_size(op: tllvmop; const dst: treference; size: tdef);
  710. begin
  711. create_llvm(op);
  712. ops:=2;
  713. loadref(0,dst);
  714. loaddef(1,size);
  715. end;
  716. { %dst = add i32 %src1, %src2 }
  717. constructor taillvm.op_reg_size_reg_reg(op: tllvmop; dst: tregister;size: tdef; src1, src2: tregister);
  718. begin
  719. create_llvm(op);
  720. ops:=4;
  721. loadreg(0,dst);
  722. loaddef(1,size);
  723. loadreg(2,src1);
  724. loadreg(3,src2);
  725. end;
  726. { %dst = shl i32 %reg, 1 (= %reg shl 1) }
  727. constructor taillvm.op_reg_size_reg_const(op: tllvmop; dst: tregister; size: tdef; src1: tregister; src2: int64);
  728. begin
  729. create_llvm(op);
  730. ops:=4;
  731. loadreg(0,dst);
  732. loaddef(1,size);
  733. loadreg(2,src1);
  734. loadconst(3,src2);
  735. end;
  736. { %dst = sub i32 1, %src (= 1 - %src) }
  737. constructor taillvm.op_reg_size_const_reg(op: tllvmop; dst: tregister; size: tdef; src1: int64; src2: tregister);
  738. begin
  739. create_llvm(op);
  740. ops:=4;
  741. loadreg(0,dst);
  742. loaddef(1,size);
  743. loadconst(2,src1);
  744. loadreg(3,src2);
  745. end;
  746. { %dst = bitcast i32 %src to i8 }
  747. constructor taillvm.op_reg_size_reg_size(op: tllvmop; dst: tregister; fromsize: tdef; src: tregister; tosize: tdef);
  748. begin
  749. create_llvm(op);
  750. ops:=4;
  751. loadreg(0,dst);
  752. loaddef(1,fromsize);
  753. loadreg(2,src);
  754. loaddef(3,tosize);
  755. end;
  756. { %dst = bitcast i32 -1 to i8 }
  757. constructor taillvm.op_reg_size_const_size(op: tllvmop; dst: tregister; fromsize: tdef; src: int64; tosize: tdef);
  758. begin
  759. create_llvm(op);
  760. ops:=4;
  761. loadreg(0,dst);
  762. loaddef(1,fromsize);
  763. loadconst(2,src);
  764. loaddef(3,tosize);
  765. end;
  766. constructor taillvm.op_reg_size_fpconst_size(op: tllvmop; dst: tregister; fromsize: tdef; src: double; tosize: tdef);
  767. begin
  768. create_llvm(op);
  769. ops:=4;
  770. loadreg(0,dst);
  771. loaddef(1,fromsize);
  772. if fromsize.typ<>floatdef then
  773. internalerror(2014012214);
  774. case tfloatdef(fromsize).floattype of
  775. s32real:
  776. loadsingle(2,src);
  777. s64real:
  778. loaddouble(2,src);
  779. else
  780. internalerror(2014012215);
  781. end;
  782. loaddef(3,tosize);
  783. end;
  784. {$ifdef cpuextended}
  785. constructor taillvm.op_reg_size_fpconst80_size(op: tllvmop; dst: tregister; fromsize: tdef; src: extended; tosize: tdef);
  786. begin
  787. create_llvm(op);
  788. ops:=4;
  789. loadreg(0,dst);
  790. loaddef(1,fromsize);
  791. loadextended(2,src);
  792. loaddef(3,tosize);
  793. end;
  794. {$endif cpuextended}
  795. constructor taillvm.op_reg_size_sym_size(op: tllvmop; dst: tregister; fromsize: tdef; src: TAsmSymbol; tosize: tdef);
  796. begin
  797. create_llvm(op);
  798. ops:=4;
  799. loadreg(0,dst);
  800. loaddef(1,fromsize);
  801. loadsymbol(2,src,0);
  802. loaddef(3,tosize);
  803. end;
  804. constructor taillvm.op_reg_tai_size(op:tllvmop;dst:tregister;src:tai;tosize:tdef);
  805. begin
  806. create_llvm(op);
  807. ops:=3;
  808. loadreg(0,dst);
  809. loadtai(1,src);
  810. loaddef(2,tosize);
  811. end;
  812. constructor taillvm.op_reg_size_undef(op: tllvmop; dst: tregister; size: tdef);
  813. begin
  814. create_llvm(op);
  815. ops:=4;
  816. loadreg(0,dst);
  817. loaddef(1,size);
  818. loadundef(2);
  819. loaddef(3,size);
  820. end;
  821. constructor taillvm.op_size_undef(op: tllvmop; size: tdef);
  822. begin
  823. create_llvm(op);
  824. ops:=2;
  825. loaddef(0,size);
  826. loadundef(1);
  827. end;
  828. constructor taillvm.op_reg_size_ref_size(op: tllvmop; dst: tregister; fromsize: tdef; const src: treference; tosize: tdef);
  829. begin
  830. create_llvm(op);
  831. ops:=4;
  832. loadreg(0,dst);
  833. loaddef(1,fromsize);
  834. loadref(2,src);
  835. loaddef(3,tosize);
  836. end;
  837. { store i32 3, i32* %ptr }
  838. constructor taillvm.op_size_reg_size_ref(op: tllvmop; fromsize: tdef; src: tregister; ptrsize: tdef; const toref: treference);
  839. begin
  840. create_llvm(op);
  841. ops:=4;
  842. loaddef(0,fromsize);
  843. loadreg(1,src);
  844. loaddef(2,ptrsize);
  845. loadref(3,toref);
  846. end;
  847. constructor taillvm.op_size_ref_size_ref(op: tllvmop; fromsize: tdef; const src: treference; ptrsize: tdef; const toref: treference);
  848. begin
  849. create_llvm(op);
  850. ops:=4;
  851. loaddef(0,fromsize);
  852. loadref(1,src);
  853. loaddef(2,ptrsize);
  854. loadref(3,toref);
  855. end;
  856. constructor taillvm.op_size_const_size_ref(op: tllvmop; fromsize: tdef; src: int64; ptrsize: tdef; const toref: treference);
  857. begin
  858. create_llvm(op);
  859. ops:=4;
  860. loaddef(0,fromsize);
  861. loadconst(1,src);
  862. loaddef(2,ptrsize);
  863. loadref(3,toref);
  864. end;
  865. constructor taillvm.op_reg_size_ref(op: tllvmop; dst: tregister; fromsize: tdef; const fromref: treference);
  866. begin
  867. create_llvm(op);
  868. ops:=3;
  869. loadreg(0,dst);
  870. loaddef(1,fromsize);
  871. loadref(2,fromref);
  872. end;
  873. constructor taillvm.op_reg_cond_size_reg_reg(op: tllvmop; dst: tregister; cmpcond: topcmp; size: tdef; reg1, reg2: tregister);
  874. begin
  875. create_llvm(op);
  876. ops:=5;
  877. loadreg(0,dst);
  878. loadcond(1,cmpcond);
  879. loaddef(2,size);
  880. loadreg(3,reg1);
  881. loadreg(4,reg2);
  882. end;
  883. constructor taillvm.op_reg_cond_size_reg_const(op: tllvmop; dst: tregister; cmpcond: topcmp; size: tdef; reg1: tregister; cnst: int64);
  884. begin
  885. create_llvm(op);
  886. ops:=5;
  887. loadreg(0,dst);
  888. loadcond(1,cmpcond);
  889. loaddef(2,size);
  890. loadreg(3,reg1);
  891. loadconst(4,cnst);
  892. end;
  893. constructor taillvm.op_reg_fpcond_size_reg_reg(op: tllvmop; dst: tregister; cmpcond: tllvmfpcmp; size: tdef; reg1, reg2: tregister);
  894. begin
  895. create_llvm(op);
  896. ops:=5;
  897. loadreg(0,dst);
  898. loadfpcond(1,cmpcond);
  899. loaddef(2,size);
  900. loadreg(3,reg1);
  901. loadreg(4,reg2);
  902. end;
  903. constructor taillvm.op_lab(op: tllvmop; lab: tasmlabel);
  904. begin
  905. create_llvm(op);
  906. ops:=1;
  907. loadsymbol(0,lab,0);
  908. end;
  909. constructor taillvm.op_size_reg_lab_lab(op: tllvmop; fromsize: tdef; condreg: tregister; labtrue, labfalse: tasmlabel);
  910. begin
  911. create_llvm(op);
  912. ops:=4;
  913. loaddef(0,fromsize);
  914. loadreg(1,condreg);
  915. loadsymbol(2,labtrue,0);
  916. loadsymbol(3,labfalse,0);
  917. end;
  918. constructor taillvm.op_size_reg(op: tllvmop; def: tdef; reg: tregister);
  919. begin
  920. create_llvm(op);
  921. ops:=2;
  922. loaddef(0,def);
  923. loadreg(1,reg);
  924. end;
  925. constructor taillvm.getelementptr_reg_size_ref_size_reg(dst: tregister; ptrsize: tdef; const ref: treference; indextype: tdef; index1: tregister; indirect: boolean);
  926. var
  927. index: longint;
  928. begin
  929. create_llvm(la_getelementptr);
  930. if indirect then
  931. ops:=7
  932. else
  933. ops:=5;
  934. loadreg(0,dst);
  935. loaddef(1,ptrsize);
  936. loadref(2,ref);
  937. if indirect then
  938. begin
  939. loaddef(3,s32inttype);
  940. loadconst(4,0);
  941. index:=5;
  942. end
  943. else
  944. index:=3;
  945. loaddef(index,indextype);
  946. loadreg(index+1,index1);
  947. end;
  948. constructor taillvm.getelementptr_reg_size_ref_size_const(dst: tregister; ptrsize: tdef; const ref: treference; indextype: tdef; index1: ptrint; indirect: boolean);
  949. var
  950. index: longint;
  951. begin
  952. create_llvm(la_getelementptr);
  953. if indirect then
  954. ops:=7
  955. else
  956. ops:=5;
  957. loadreg(0,dst);
  958. loaddef(1,ptrsize);
  959. loadref(2,ref);
  960. if indirect then
  961. begin
  962. loaddef(3,s32inttype);
  963. loadconst(4,0);
  964. index:=5;
  965. end
  966. else
  967. index:=3;
  968. loaddef(index,indextype);
  969. loadconst(index+1,index1);
  970. end;
  971. constructor taillvm.getelementptr_reg_tai_size_const(dst: tregister; const ai: tai; indextype: tdef; index1: ptrint; indirect: boolean);
  972. var
  973. index: longint;
  974. begin
  975. create_llvm(la_getelementptr);
  976. if indirect then
  977. ops:=6
  978. else
  979. ops:=4;
  980. loadreg(0,dst);
  981. loadtai(1,ai);
  982. if indirect then
  983. begin
  984. loaddef(2,s32inttype);
  985. loadconst(3,0);
  986. index:=4;
  987. end
  988. else
  989. index:=2;
  990. loaddef(index,indextype);
  991. loadconst(index+1,index1);
  992. end;
  993. constructor taillvm.blockaddress(size: tdef; fun, lab: tasmsymbol);
  994. begin
  995. create_llvm(la_blockaddress);
  996. ops:=3;
  997. loaddef(0,size);
  998. loadsymbol(1,fun,0);
  999. loadsymbol(2,lab,0);
  1000. end;
  1001. constructor taillvm.landingpad(dst: tregister; def: tdef; firstclause: taillvm);
  1002. begin
  1003. create_llvm(la_landingpad);
  1004. ops:=3;
  1005. loadreg(0,dst);
  1006. loaddef(1,def);
  1007. loadtai(2,firstclause);
  1008. end;
  1009. constructor taillvm.exceptclause(op: tllvmop; def: tdef; kind: TAsmSymbol; nextclause: taillvm);
  1010. var
  1011. ref: treference;
  1012. begin
  1013. create_llvm(op);
  1014. ops:=3;
  1015. loaddef(0,def);
  1016. reference_reset_symbol(ref,kind,0,def.alignment,[]);
  1017. loadref(1,ref);
  1018. loadtai(2,nextclause);
  1019. end;
  1020. constructor taillvm.cleanupclause;
  1021. begin
  1022. create_llvm(la_cleanup);
  1023. ops:=0;
  1024. end;
  1025. constructor taillvm.call_size_name_paras(callpd: tdef; cc: tproccalloption; dst: tregister; retsize: tdef; name:tasmsymbol; paras: tfplist);
  1026. begin
  1027. create_llvm(la_call);
  1028. ops:=6;
  1029. { we need this in case the call symbol is an alias for a symbol with a
  1030. different def in the same module (via "external"), because then we
  1031. have to insert a type conversion later from the alias def to the
  1032. call def here; we can't always do that at the point the call itself
  1033. is generated, because the alias declaration may occur anywhere }
  1034. loaddef(0,retsize);
  1035. loadreg(1,dst);
  1036. loadcallingconvention(2,cc);
  1037. loaddef(3,callpd);
  1038. loadsymbol(4,name,0);
  1039. loadparas(5,paras);
  1040. end;
  1041. constructor taillvm.call_size_reg_paras(callpd: tdef; cc: tproccalloption; dst: tregister; retsize: tdef; reg: tregister; paras: tfplist);
  1042. begin
  1043. create_llvm(la_call);
  1044. ops:=6;
  1045. loaddef(0,retsize);
  1046. loadreg(1,dst);
  1047. loadcallingconvention(2,cc);
  1048. loaddef(3,callpd);
  1049. loadreg(4,reg);
  1050. loadparas(5,paras);
  1051. end;
  1052. constructor taillvm.invoke_size_name_paras_retlab_exceptlab(callpd: tdef; cc: tproccalloption; dst: tregister; retsize: tdef; name: tasmsymbol; paras: tfplist; retlab, exceptlab: TAsmLabel);
  1053. begin
  1054. create_llvm(la_invoke);
  1055. ops:=8;
  1056. loaddef(0,retsize);
  1057. loadreg(1,dst);
  1058. loadcallingconvention(2,cc);
  1059. loaddef(3,callpd);
  1060. loadsymbol(4,name,0);
  1061. loadparas(5,paras);
  1062. loadsymbol(6,retlab,0);
  1063. loadsymbol(7,exceptlab,0);
  1064. end;
  1065. constructor taillvm.invoke_size_reg_paras_retlab_exceptlab(callpd: tdef; cc: tproccalloption; dst: tregister; retsize: tdef; reg: tregister; paras: tfplist; retlab, exceptlab: TAsmLabel);
  1066. begin
  1067. create_llvm(la_invoke);
  1068. ops:=8;
  1069. loaddef(0,retsize);
  1070. loadreg(1,dst);
  1071. loadcallingconvention(2,cc);
  1072. loaddef(3,callpd);
  1073. loadreg(4,reg);
  1074. loadparas(5,paras);
  1075. loadsymbol(6,retlab,0);
  1076. loadsymbol(7,exceptlab,0);
  1077. end;
  1078. constructor taillvm.extract(op: tllvmop; dst: tregister; srcsize: tdef; src: tregister; idx: longint);
  1079. begin
  1080. create_llvm(op);
  1081. ops:=4;
  1082. loadreg(0,dst);
  1083. loaddef(1,srcsize);
  1084. loadreg(2,src);
  1085. loadconst(3,idx)
  1086. end;
  1087. constructor taillvm.asm_paras(asmlist: tasmlist; paras: tfplist);
  1088. begin
  1089. create_llvm(la_asmblock);
  1090. ops:=2;
  1091. loadasmlist(0,asmlist);
  1092. loadparas(1,paras);
  1093. end;
  1094. end.