aasmllvm.pas 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723
  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,
  22. aasmbase,aasmtai,aasmdata,aasmsym,
  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. constructor create_llvm(op: tllvmop);
  31. { e.g. ret void }
  32. constructor op_size(op : tllvmop; size: tdef);
  33. { e.g. dst = alloca size }
  34. constructor op_reg_size(op:tllvmop;dst:tregister;size:tdef);
  35. { e.g. dst = alloca size }
  36. constructor op_ref_size(op:tllvmop;const dst:treference;size:tdef);
  37. { e.g. dst = add size src1, src2 }
  38. constructor op_reg_size_reg_reg(op:tllvmop;dst:tregister;size:tdef;src1,src2:tregister);
  39. { e.g. dst = shl size src1, 1 ( = src1 shl 1) }
  40. constructor op_reg_size_reg_const(op:tllvmop;dst:tregister;size:tdef;src1:tregister;src2:int64);
  41. { e.g. dst = sub size 0, src2 ( = 0 - src2) }
  42. constructor op_reg_size_const_reg(op:tllvmop;dst:tregister;size:tdef;src1:int64;src2:tregister);
  43. { e.g. dst = bitcast size1 src to tosize }
  44. constructor op_reg_size_reg_size(op:tllvmop;dst:tregister;fromsize:tdef;src:tregister;tosize:tdef);
  45. { e.g. dst = bitcast fromsize 255 to tosize }
  46. constructor op_reg_size_const_size(op:tllvmop;dst:tregister;fromsize:tdef;src:int64;tosize:tdef);
  47. { e.g. dst = bitcast fromsize double to tosize }
  48. constructor op_reg_size_fpconst_size(op:tllvmop;dst:tregister;fromsize:tdef;src:double;tosize:tdef);
  49. {$ifdef cpuextended}
  50. { e.g. dst = bitcast fromsize extended to tosize }
  51. constructor op_reg_size_fpconst80_size(op:tllvmop;dst:tregister;fromsize:tdef;src:extended;tosize:tdef);
  52. {$endif cpuextended}
  53. { e.g. dst = bitcast fromsize @globalvar to tosize }
  54. constructor op_reg_size_sym_size(op:tllvmop;dst:tregister;fromsize:tdef;src:TAsmSymbol;tosize:tdef);
  55. { e.g. dst = bitcast fromsize src to tosize }
  56. constructor op_reg_size_ref_size(op:tllvmop;dst:tregister;fromsize:tdef;const src:treference;tosize:tdef);
  57. { e.g. store fromsize src, ptrsize toref}
  58. constructor op_size_reg_size_ref(op:tllvmop;fromsize:tdef;src:tregister;ptrsize:tdef;const toref:treference);
  59. { e.g. store fromsize srcref, ptrsize toref (with srcref.refaddr=full) }
  60. constructor op_size_ref_size_ref(op:tllvmop;fromsize:tdef;const src:treference;ptrsize:tdef;const toref:treference);
  61. { e.g. store fromsize const, ptrsize toref}
  62. constructor op_size_const_size_ref(op:tllvmop;fromsize:tdef;src:int64;ptrsize:tdef;const toref:treference);
  63. { e.g. dst = load fromsize fromref }
  64. constructor op_reg_size_ref(op:tllvmop;dst:tregister;fromsize:tdef;const fromref:treference);
  65. { e.g. dst = icmp cmpcond size reg1, reg2 }
  66. constructor op_reg_cond_size_reg_reg(op:tllvmop;dst:tregister;cmpcond:topcmp;size:tdef;reg1,reg2:tregister);
  67. { e.g. dst = icmp cmpcond size reg1, constant }
  68. constructor op_reg_cond_size_reg_const(op:tllvmop;dst:tregister;cmpcond:topcmp;size:tdef;reg1:tregister;cnst:int64);
  69. { e.g. dst = fcmp cmpcond size reg1, reg2 }
  70. constructor op_reg_fpcond_size_reg_reg(op:tllvmop;dst:tregister;cmpcond:tllvmfpcmp;size:tdef;reg1,reg2:tregister);
  71. { e.g. br label lab }
  72. constructor op_lab(op:tllvmop;lab:tasmlabel);
  73. { e.g. br i1 condreg, label iftrue, label iffalse }
  74. constructor op_size_reg_lab_lab(op:tllvmop;fromsize:tdef;condreg:tregister;labtrue,labfalse: tasmlabel);
  75. { e.g. la_ret retdef retval }
  76. constructor op_size_reg(op:tllvmop;def: tdef;reg: tregister);
  77. { e.g. dst = getelementptr ptrsize ref, i32 0 (if indirect), index1type index1 }
  78. constructor getelementptr_reg_size_ref_size_reg(dst:tregister;ptrsize:tdef;const ref:treference;indextype:tdef;index1:tregister;indirect:boolean);
  79. constructor getelementptr_reg_size_ref_size_const(dst:tregister;ptrsize:tdef;const ref:treference;indextype:tdef;index1:ptrint;indirect:boolean);
  80. procedure loaddef(opidx: longint; _def: tdef);
  81. procedure loadsingle(opidx: longint; _sval: single);
  82. procedure loaddouble(opidx: longint; _dval: double);
  83. {$ifdef cpuextended}
  84. procedure loadextended(opidx: longint; _eval: extended);
  85. {$endif cpuextended}
  86. procedure loadcond(opidx: longint; _cond: topcmp);
  87. procedure loadfpcond(opidx: longint; _fpcond: tllvmfpcmp);
  88. { register spilling code }
  89. function spilling_get_operation_type(opnr: longint): topertype;override;
  90. function spilling_get_reg_type(opnr: longint): tdef;
  91. end;
  92. tllvmvisibility = (llv_default, llv_hidden, llv_protected);
  93. tllvmlinkage = (
  94. { llvm 2.5 }
  95. lll_default { = externally visible/global },
  96. lll_private, lll_internal, lll_linkonce, lll_common,
  97. lll_weak, lll_appending, lll_extern_weak,
  98. lll_dllimport, lll_dllexport,
  99. { llvm 2.6+ }
  100. lll_linker_private, lll_private_weak, lll_private_weak_def_auto,
  101. lll_available_externally,lll_linkonce_odr, lll_weak_odr
  102. );
  103. taillvmalias = class(tailineinfo)
  104. vis: tllvmvisibility;
  105. linkage: tllvmlinkage;
  106. oldsym, newsym: TAsmSymbol;
  107. def: tdef;
  108. constructor Create(const oldname, newname: TSymStr; _def: tdef; _vis: tllvmvisibility; _linkage: tllvmlinkage);
  109. end;
  110. { start of a procedure }
  111. taillvmprocdef = class(tailineinfo)
  112. procdef: tprocdef;
  113. constructor create(_procdef: tprocdef);
  114. end;
  115. { global variable definition }
  116. taillvmvarsym = class(tailineinfo)
  117. varsym: tstaticvarsym;
  118. constructor create(_varsym: tstaticvarsym);
  119. end;
  120. implementation
  121. uses
  122. cutils, cclasses, strings, aasmcpu;
  123. { taillvmvarsym }
  124. constructor taillvmvarsym.create(_varsym: tstaticvarsym);
  125. begin
  126. inherited create;
  127. typ:=ait_llvmvarsym;
  128. varsym:=_varsym;
  129. end;
  130. { taillvmalias }
  131. constructor taillvmalias.Create(const oldname, newname: TSymStr; _def: tdef; _vis: tllvmvisibility; _linkage: tllvmlinkage);
  132. begin
  133. inherited Create;
  134. oldsym:=current_asmdata.RefAsmSymbol(oldname,AT_FUNCTION);
  135. newsym:=current_asmdata.DefineAsmSymbol(newname,AB_GLOBAL,AT_FUNCTION);
  136. def:=_def;
  137. vis:=_vis;
  138. linkage:=_linkage;
  139. end;
  140. { taillvmprocdef }
  141. constructor taillvmprocdef.create(_procdef: tprocdef);
  142. begin
  143. inherited create;
  144. typ:=ait_llvmprocdef;
  145. procdef:=_procdef;
  146. end;
  147. {*****************************************************************************
  148. taicpu Constructors
  149. *****************************************************************************}
  150. constructor taillvm.create_llvm(op: tllvmop);
  151. begin
  152. create(a_none);
  153. llvmopcode:=op;
  154. typ:=ait_llvmins;
  155. end;
  156. procedure taillvm.loaddef(opidx:longint;_def: tdef);
  157. begin
  158. allocate_oper(opidx+1);
  159. with oper[opidx]^ do
  160. begin
  161. if typ<>top_def then
  162. clearop(opidx);
  163. def:=_def;
  164. typ:=top_def;
  165. end;
  166. end;
  167. procedure taillvm.loadsingle(opidx: longint; _sval: single);
  168. begin
  169. allocate_oper(opidx+1);
  170. with oper[opidx]^ do
  171. begin
  172. if typ<>top_single then
  173. clearop(opidx);
  174. sval:=_sval;
  175. typ:=top_single;
  176. end;
  177. end;
  178. procedure taillvm.loaddouble(opidx: longint; _dval: double);
  179. begin
  180. allocate_oper(opidx+1);
  181. with oper[opidx]^ do
  182. begin
  183. if typ<>top_double then
  184. clearop(opidx);
  185. dval:=_dval;
  186. typ:=top_double;
  187. end;
  188. end;
  189. {$ifdef cpuextended}
  190. procedure taillvm.loadextended(opidx: longint; _eval: extended);
  191. begin
  192. allocate_oper(opidx+1);
  193. with oper[opidx]^ do
  194. begin
  195. if typ<>top_extended80 then
  196. clearop(opidx);
  197. eval:=_eval;
  198. typ:=top_extended80;
  199. end;
  200. end;
  201. {$endif cpuextended}
  202. procedure taillvm.loadcond(opidx: longint; _cond: topcmp);
  203. begin
  204. allocate_oper(opidx+1);
  205. with oper[opidx]^ do
  206. begin
  207. if typ<>top_cond then
  208. clearop(opidx);
  209. cond:=_cond;
  210. typ:=top_cond;
  211. end;
  212. end;
  213. procedure taillvm.loadfpcond(opidx: longint; _fpcond: tllvmfpcmp);
  214. begin
  215. allocate_oper(opidx+1);
  216. with oper[opidx]^ do
  217. begin
  218. if typ<>top_fpcond then
  219. clearop(opidx);
  220. fpcond:=_fpcond;
  221. typ:=top_fpcond;
  222. end;
  223. end;
  224. function taillvm.spilling_get_operation_type(opnr: longint): topertype;
  225. begin
  226. case llvmopcode of
  227. la_ret, la_br, la_switch, la_indirectbr,
  228. la_invoke, la_resume,
  229. la_unreachable,
  230. la_store,
  231. la_fence,
  232. la_cmpxchg,
  233. la_atomicrmw:
  234. begin
  235. { instructions that never have a result }
  236. result:=operand_read;
  237. end;
  238. la_alloca,
  239. la_trunc, la_zext, la_sext, la_fptrunc, la_fpext,
  240. la_fptoui, la_fptosi, la_uitofp, la_sitofp,
  241. la_ptrtoint, la_inttoptr,
  242. la_bitcast,
  243. la_add, la_fadd, la_sub, la_fsub, la_mul, la_fmul,
  244. la_udiv,la_sdiv, la_fdiv, la_urem, la_srem, la_frem,
  245. la_shl, la_lshr, la_ashr, la_and, la_or, la_xor,
  246. la_extractelement, la_insertelement, la_shufflevector,
  247. la_extractvalue, la_insertvalue,
  248. la_getelementptr,
  249. la_load,
  250. la_icmp, la_fcmp,
  251. la_phi, la_select, la_call,
  252. la_va_arg, la_landingpad:
  253. begin
  254. if opnr=0 then
  255. result:=operand_write
  256. else
  257. result:=operand_read;
  258. end;
  259. else
  260. internalerror(2013103101)
  261. end;
  262. end;
  263. function taillvm.spilling_get_reg_type(opnr: longint): tdef;
  264. begin
  265. case llvmopcode of
  266. la_trunc, la_zext, la_sext, la_fptrunc, la_fpext,
  267. la_fptoui, la_fptosi, la_uitofp, la_sitofp,
  268. la_ptrtoint, la_inttoptr,
  269. la_bitcast:
  270. begin
  271. { toreg = bitcast fromsize fromreg to tosize }
  272. case opnr of
  273. 0: result:=oper[3]^.def;
  274. 2: result:=oper[1]^.def
  275. else
  276. internalerror(2013103102);
  277. end;
  278. end;
  279. la_ret, la_switch, la_indirectbr,
  280. la_resume:
  281. begin
  282. { ret size reg }
  283. if opnr=1 then
  284. result:=oper[0]^.def
  285. else
  286. internalerror(2013110101);
  287. end;
  288. la_invoke, la_call:
  289. begin
  290. internalerror(2013110102);
  291. end;
  292. la_br,
  293. la_unreachable:
  294. internalerror(2013110103);
  295. la_store:
  296. begin
  297. case opnr of
  298. 1: result:=oper[0]^.def;
  299. { type of the register in the reference }
  300. 3: result:=oper[2]^.def;
  301. else
  302. internalerror(2013110104);
  303. end;
  304. end;
  305. la_load,
  306. la_getelementptr:
  307. begin
  308. { dst = load ptrdef srcref }
  309. case opnr of
  310. 0: result:=tpointerdef(oper[1]^.def).pointeddef;
  311. 2: result:=oper[1]^.def;
  312. else
  313. internalerror(2013110105);
  314. end;
  315. end;
  316. la_fence,
  317. la_cmpxchg,
  318. la_atomicrmw:
  319. begin
  320. internalerror(2013110610);
  321. end;
  322. la_add, la_fadd, la_sub, la_fsub, la_mul, la_fmul,
  323. la_udiv,la_sdiv, la_fdiv, la_urem, la_srem, la_frem,
  324. la_shl, la_lshr, la_ashr, la_and, la_or, la_xor:
  325. begin
  326. case opnr of
  327. 0,2,3:
  328. result:=oper[1]^.def;
  329. else
  330. internalerror(2013110106);
  331. end;
  332. end;
  333. la_extractelement, la_insertelement, la_shufflevector,
  334. la_extractvalue:
  335. begin
  336. { todo }
  337. internalerror(2013110107);
  338. end;
  339. la_insertvalue:
  340. begin
  341. case opnr of
  342. 0,2: result:=oper[1]^.def;
  343. else
  344. internalerror(2013110108);
  345. end;
  346. end;
  347. la_icmp, la_fcmp:
  348. begin
  349. case opnr of
  350. 0: result:=pasbool8type;
  351. 3,4: result:=oper[2]^.def;
  352. else
  353. internalerror(2013110801);
  354. end
  355. end;
  356. la_alloca:
  357. begin
  358. { shouldn't be spilled, the result of alloca should be read-only }
  359. internalerror(2013110109);
  360. end;
  361. la_select:
  362. begin
  363. case opnr of
  364. 0,4,6: result:=oper[3]^.def;
  365. 2: result:=oper[1]^.def;
  366. else
  367. internalerror(2013110110);
  368. end;
  369. end;
  370. else
  371. internalerror(2013103101)
  372. end;
  373. end;
  374. constructor taillvm.op_size(op : tllvmop; size: tdef);
  375. begin
  376. create_llvm(op);
  377. ops:=1;
  378. loaddef(0,size);
  379. end;
  380. constructor taillvm.op_reg_size(op: tllvmop; dst: tregister; size: tdef);
  381. begin
  382. create_llvm(op);
  383. ops:=2;
  384. loadreg(0,dst);
  385. loaddef(1,size);
  386. end;
  387. constructor taillvm.op_ref_size(op: tllvmop; const dst: treference; size: tdef);
  388. begin
  389. create_llvm(op);
  390. ops:=2;
  391. loadref(0,dst);
  392. loaddef(1,size);
  393. end;
  394. { %dst = add i32 %src1, %src2 }
  395. constructor taillvm.op_reg_size_reg_reg(op: tllvmop; dst: tregister;size: tdef; src1, src2: tregister);
  396. begin
  397. create_llvm(op);
  398. ops:=4;
  399. loadreg(0,dst);
  400. loaddef(1,size);
  401. loadreg(2,src1);
  402. loadreg(3,src2);
  403. end;
  404. { %dst = shl i32 %reg, 1 (= %reg shl 1) }
  405. constructor taillvm.op_reg_size_reg_const(op: tllvmop; dst: tregister; size: tdef; src1: tregister; src2: int64);
  406. begin
  407. create_llvm(op);
  408. ops:=4;
  409. loadreg(0,dst);
  410. loaddef(1,size);
  411. loadreg(2,src1);
  412. loadconst(3,src2);
  413. end;
  414. { %dst = sub i32 1, %src (= 1 - %src) }
  415. constructor taillvm.op_reg_size_const_reg(op: tllvmop; dst: tregister; size: tdef; src1: int64; src2: tregister);
  416. begin
  417. create_llvm(op);
  418. ops:=4;
  419. loadreg(0,dst);
  420. loaddef(1,size);
  421. loadconst(2,src1);
  422. loadreg(3,src2);
  423. end;
  424. { %dst = bitcast i32 %src to i8 }
  425. constructor taillvm.op_reg_size_reg_size(op: tllvmop; dst: tregister; fromsize: tdef; src: tregister; tosize: tdef);
  426. begin
  427. create_llvm(op);
  428. ops:=4;
  429. loadreg(0,dst);
  430. loaddef(1,fromsize);
  431. loadreg(2,src);
  432. loaddef(3,tosize);
  433. end;
  434. { %dst = bitcast i32 -1 to i8 }
  435. constructor taillvm.op_reg_size_const_size(op: tllvmop; dst: tregister; fromsize: tdef; src: int64; tosize: tdef);
  436. begin
  437. create_llvm(op);
  438. ops:=4;
  439. loadreg(0,dst);
  440. loaddef(1,fromsize);
  441. loadconst(2,src);
  442. loaddef(3,tosize);
  443. end;
  444. constructor taillvm.op_reg_size_fpconst_size(op: tllvmop; dst: tregister; fromsize: tdef; src: double; tosize: tdef);
  445. begin
  446. create_llvm(op);
  447. ops:=4;
  448. loadreg(0,dst);
  449. loaddef(1,fromsize);
  450. if fromsize.typ<>floatdef then
  451. internalerror(2014012214);
  452. case tfloatdef(fromsize).floattype of
  453. s32real:
  454. loadsingle(2,src);
  455. s64real:
  456. loaddouble(2,src);
  457. else
  458. internalerror(2014012215);
  459. end;
  460. loaddef(3,tosize);
  461. end;
  462. {$ifdef cpuextended}
  463. constructor taillvm.op_reg_size_fpconst80_size(op: tllvmop; dst: tregister; fromsize: tdef; src: extended; tosize: tdef);
  464. begin
  465. create_llvm(op);
  466. ops:=4;
  467. loadreg(0,dst);
  468. loaddef(1,fromsize);
  469. loadextended(2,src);
  470. loaddef(3,tosize);
  471. end;
  472. {$endif cpuextended}
  473. constructor taillvm.op_reg_size_sym_size(op: tllvmop; dst: tregister; fromsize: tdef; src: TAsmSymbol; tosize: tdef);
  474. begin
  475. create_llvm(op);
  476. ops:=4;
  477. loadreg(0,dst);
  478. loaddef(1,fromsize);
  479. loadsymbol(2,src,0);
  480. loaddef(3,tosize);
  481. end;
  482. { store i32 3, i32* %ptr }
  483. constructor taillvm.op_reg_size_ref_size(op: tllvmop; dst: tregister; fromsize: tdef; const src: treference; tosize: tdef);
  484. begin
  485. create_llvm(op);
  486. ops:=4;
  487. loadreg(0,dst);
  488. loaddef(1,fromsize);
  489. loadref(2,src);
  490. loaddef(3,tosize);
  491. end;
  492. constructor taillvm.op_size_reg_size_ref(op: tllvmop; fromsize: tdef; src: tregister; ptrsize: tdef; const toref: treference);
  493. begin
  494. create_llvm(op);
  495. ops:=4;
  496. loaddef(0,fromsize);
  497. loadreg(1,src);
  498. loaddef(2,ptrsize);
  499. loadref(3,toref);
  500. end;
  501. constructor taillvm.op_size_ref_size_ref(op: tllvmop; fromsize: tdef; const src: treference; ptrsize: tdef; const toref: treference);
  502. begin
  503. create_llvm(op);
  504. ops:=4;
  505. loaddef(0,fromsize);
  506. loadref(1,src);
  507. loaddef(2,ptrsize);
  508. loadref(3,toref);
  509. end;
  510. constructor taillvm.op_size_const_size_ref(op: tllvmop; fromsize: tdef; src: int64; ptrsize: tdef; const toref: treference);
  511. begin
  512. create_llvm(op);
  513. ops:=4;
  514. loaddef(0,fromsize);
  515. loadconst(1,src);
  516. loaddef(2,ptrsize);
  517. loadref(3,toref);
  518. end;
  519. constructor taillvm.op_reg_size_ref(op: tllvmop; dst: tregister; fromsize: tdef; const fromref: treference);
  520. begin
  521. create_llvm(op);
  522. ops:=3;
  523. loadreg(0,dst);
  524. loaddef(1,fromsize);
  525. loadref(2,fromref);
  526. end;
  527. constructor taillvm.op_reg_cond_size_reg_reg(op: tllvmop; dst: tregister; cmpcond: topcmp; size: tdef; reg1, reg2: tregister);
  528. begin
  529. create_llvm(op);
  530. ops:=5;
  531. loadreg(0,dst);
  532. loadcond(1,cmpcond);
  533. loaddef(2,size);
  534. loadreg(3,reg1);
  535. loadreg(4,reg2);
  536. end;
  537. constructor taillvm.op_reg_cond_size_reg_const(op: tllvmop; dst: tregister; cmpcond: topcmp; size: tdef; reg1: tregister; cnst: int64);
  538. begin
  539. create_llvm(op);
  540. ops:=5;
  541. loadreg(0,dst);
  542. loadcond(1,cmpcond);
  543. loaddef(2,size);
  544. loadreg(3,reg1);
  545. loadconst(4,cnst);
  546. end;
  547. constructor taillvm.op_reg_fpcond_size_reg_reg(op: tllvmop; dst: tregister; cmpcond: tllvmfpcmp; size: tdef; reg1, reg2: tregister);
  548. begin
  549. create_llvm(op);
  550. ops:=5;
  551. loadreg(0,dst);
  552. loadfpcond(1,cmpcond);
  553. loaddef(2,size);
  554. loadreg(3,reg1);
  555. loadreg(4,reg2);
  556. end;
  557. constructor taillvm.op_lab(op: tllvmop; lab: tasmlabel);
  558. begin
  559. create_llvm(op);
  560. ops:=1;
  561. loadsymbol(0,lab,0);
  562. end;
  563. constructor taillvm.op_size_reg_lab_lab(op: tllvmop; fromsize: tdef; condreg: tregister; labtrue, labfalse: tasmlabel);
  564. begin
  565. create_llvm(op);
  566. ops:=4;
  567. loaddef(0,fromsize);
  568. loadreg(1,condreg);
  569. loadsymbol(2,labtrue,0);
  570. loadsymbol(3,labfalse,0);
  571. end;
  572. constructor taillvm.op_size_reg(op: tllvmop; def: tdef; reg: tregister);
  573. begin
  574. create_llvm(op);
  575. ops:=2;
  576. loaddef(0,def);
  577. loadreg(1,reg);
  578. end;
  579. constructor taillvm.getelementptr_reg_size_ref_size_reg(dst: tregister; ptrsize: tdef; const ref: treference; indextype: tdef; index1: tregister; indirect: boolean);
  580. var
  581. index: longint;
  582. begin
  583. create_llvm(la_getelementptr);
  584. if indirect then
  585. ops:=7
  586. else
  587. ops:=5;
  588. loadreg(0,dst);
  589. loaddef(1,ptrsize);
  590. loadref(2,ref);
  591. if indirect then
  592. begin
  593. loaddef(3,s32inttype);
  594. loadconst(4,0);
  595. index:=5;
  596. end
  597. else
  598. index:=3;
  599. loaddef(index,indextype);
  600. loadreg(index+1,index1);
  601. end;
  602. constructor taillvm.getelementptr_reg_size_ref_size_const(dst: tregister; ptrsize: tdef; const ref: treference; indextype: tdef; index1: ptrint; indirect: boolean);
  603. var
  604. index: longint;
  605. begin
  606. create_llvm(la_getelementptr);
  607. if indirect then
  608. ops:=7
  609. else
  610. ops:=5;
  611. loadreg(0,dst);
  612. loaddef(1,ptrsize);
  613. loadref(2,ref);
  614. if indirect then
  615. begin
  616. loaddef(3,s32inttype);
  617. loadconst(4,0);
  618. index:=5;
  619. end
  620. else
  621. index:=3;
  622. loaddef(index,indextype);
  623. loadconst(index+1,index1);
  624. end;
  625. end.