ncgmem.pas 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764
  1. {
  2. Copyright (c) 1998-2002 by Florian Klaempfl
  3. Generate assembler for memory related nodes which are
  4. the same for all (most?) processors
  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 ncgmem;
  19. {$i fpcdefs.inc}
  20. interface
  21. uses
  22. globtype,cgbase,cpuinfo,cpubase,
  23. node,nmem;
  24. type
  25. tcgloadvmtaddrnode = class(tloadvmtaddrnode)
  26. procedure pass_2;override;
  27. end;
  28. tcgloadparentfpnode = class(tloadparentfpnode)
  29. procedure pass_2;override;
  30. end;
  31. tcgaddrnode = class(taddrnode)
  32. procedure pass_2;override;
  33. end;
  34. tcgderefnode = class(tderefnode)
  35. procedure pass_2;override;
  36. end;
  37. tcgsubscriptnode = class(tsubscriptnode)
  38. procedure pass_2;override;
  39. end;
  40. tcgwithnode = class(twithnode)
  41. procedure pass_2;override;
  42. end;
  43. tcgvecnode = class(tvecnode)
  44. private
  45. procedure rangecheck_array;
  46. protected
  47. function get_mul_size : aint;
  48. {# This routine is used to calculate the address of the reference.
  49. On entry reg contains the index in the array,
  50. and l contains the size of each element in the array.
  51. This routine should update location.reference correctly,
  52. so it points to the correct address.
  53. }
  54. procedure update_reference_reg_mul(reg:tregister;l:aint);virtual;
  55. procedure second_wideansistring;virtual;
  56. procedure second_dynamicarray;virtual;
  57. public
  58. procedure pass_2;override;
  59. end;
  60. implementation
  61. uses
  62. systems,
  63. cutils,verbose,globals,
  64. symconst,symdef,symsym,defutil,paramgr,
  65. aasmbase,aasmtai,
  66. procinfo,pass_2,parabase,
  67. pass_1,nld,ncon,nadd,nutils,
  68. cgutils,cgobj,
  69. tgobj,ncgutil
  70. ;
  71. {*****************************************************************************
  72. TCGLOADVMTADDRNODE
  73. *****************************************************************************}
  74. procedure tcgloadvmtaddrnode.pass_2;
  75. var
  76. href : treference;
  77. begin
  78. location_reset(location,LOC_REGISTER,OS_ADDR);
  79. if (left.nodetype=typen) then
  80. begin
  81. reference_reset_symbol(href,
  82. objectlibrary.newasmsymbol(tobjectdef(tclassrefdef(resulttype.def).pointertype.def).vmt_mangledname,AB_EXTERNAL,AT_DATA),0);
  83. location.register:=cg.getaddressregister(exprasmlist);
  84. cg.a_loadaddr_ref_reg(exprasmlist,href,location.register);
  85. end
  86. else
  87. begin
  88. { left contains self, load vmt from self }
  89. secondpass(left);
  90. gen_load_vmt_register(exprasmlist,tobjectdef(left.resulttype.def),left.location,location.register);
  91. end;
  92. end;
  93. {*****************************************************************************
  94. TCGLOADPARENTFPNODE
  95. *****************************************************************************}
  96. procedure tcgloadparentfpnode.pass_2;
  97. var
  98. currpi : tprocinfo;
  99. hsym : tparavarsym;
  100. href : treference;
  101. begin
  102. if (current_procinfo.procdef.parast.symtablelevel=parentpd.parast.symtablelevel) then
  103. begin
  104. location_reset(location,LOC_REGISTER,OS_ADDR);
  105. location.register:=current_procinfo.framepointer;
  106. end
  107. else
  108. begin
  109. currpi:=current_procinfo;
  110. location_reset(location,LOC_REGISTER,OS_ADDR);
  111. location.register:=cg.getaddressregister(exprasmlist);
  112. { load framepointer of current proc }
  113. hsym:=tparavarsym(currpi.procdef.parast.search('parentfp'));
  114. if not assigned(hsym) then
  115. internalerror(200309281);
  116. cg.a_load_loc_reg(exprasmlist,OS_ADDR,hsym.localloc,location.register);
  117. { walk parents }
  118. while (currpi.procdef.owner.symtablelevel>parentpd.parast.symtablelevel) do
  119. begin
  120. currpi:=currpi.parent;
  121. if not assigned(currpi) then
  122. internalerror(200311201);
  123. hsym:=tparavarsym(currpi.procdef.parast.search('parentfp'));
  124. if not assigned(hsym) then
  125. internalerror(200309282);
  126. if hsym.localloc.loc<>LOC_REFERENCE then
  127. internalerror(200309283);
  128. reference_reset_base(href,location.register,hsym.localloc.reference.offset);
  129. cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,href,location.register);
  130. end;
  131. end;
  132. end;
  133. {*****************************************************************************
  134. TCGADDRNODE
  135. *****************************************************************************}
  136. procedure tcgaddrnode.pass_2;
  137. begin
  138. secondpass(left);
  139. location_reset(location,LOC_REGISTER,OS_ADDR);
  140. location.register:=cg.getaddressregister(exprasmlist);
  141. cg.a_loadaddr_ref_reg(exprasmlist,left.location.reference,location.register);
  142. end;
  143. {*****************************************************************************
  144. TCGDEREFNODE
  145. *****************************************************************************}
  146. procedure tcgderefnode.pass_2;
  147. var
  148. paraloc1 : tcgpara;
  149. begin
  150. secondpass(left);
  151. location_reset(location,LOC_REFERENCE,def_cgsize(resulttype.def));
  152. case left.location.loc of
  153. LOC_CREGISTER,
  154. LOC_REGISTER:
  155. begin
  156. {$ifdef cpu_uses_separate_address_registers}
  157. if getregtype(left.location.register)<>R_ADDRESSREGISTER then
  158. begin
  159. location.reference.base := cg.getaddressregister(exprasmlist);
  160. cg.a_load_reg_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.register,
  161. location.reference.base);
  162. end
  163. else
  164. {$endif}
  165. location.reference.base := left.location.register;
  166. end;
  167. LOC_CREFERENCE,
  168. LOC_REFERENCE:
  169. begin
  170. location.reference.base:=cg.getaddressregister(exprasmlist);
  171. cg.a_load_loc_reg(exprasmlist,OS_ADDR,left.location,location.reference.base);
  172. end;
  173. LOC_CONSTANT:
  174. begin
  175. location.reference.offset:=left.location.value;
  176. end;
  177. else
  178. internalerror(200507031);
  179. end;
  180. if (cs_use_heaptrc in aktglobalswitches) and
  181. (cs_checkpointer in aktlocalswitches) and
  182. not(cs_compilesystem in aktmoduleswitches) and
  183. not(tpointerdef(left.resulttype.def).is_far) and
  184. not(nf_no_checkpointer in flags) then
  185. begin
  186. paraloc1.init;
  187. paramanager.getintparaloc(pocall_default,1,paraloc1);
  188. paramanager.allocparaloc(exprasmlist,paraloc1);
  189. cg.a_param_reg(exprasmlist, OS_ADDR,location.reference.base,paraloc1);
  190. paramanager.freeparaloc(exprasmlist,paraloc1);
  191. paraloc1.done;
  192. cg.allocallcpuregisters(exprasmlist);
  193. cg.a_call_name(exprasmlist,'FPC_CHECKPOINTER');
  194. cg.deallocallcpuregisters(exprasmlist);
  195. end;
  196. end;
  197. {*****************************************************************************
  198. TCGSUBSCRIPTNODE
  199. *****************************************************************************}
  200. procedure tcgsubscriptnode.pass_2;
  201. var
  202. paraloc1 : tcgpara;
  203. begin
  204. secondpass(left);
  205. if codegenerror then
  206. exit;
  207. paraloc1.init;
  208. { classes and interfaces must be dereferenced implicit }
  209. if is_class_or_interface(left.resulttype.def) then
  210. begin
  211. location_reset(location,LOC_REFERENCE,def_cgsize(resulttype.def));
  212. case left.location.loc of
  213. LOC_CREGISTER,
  214. LOC_REGISTER:
  215. begin
  216. {$ifdef cpu_uses_separate_address_registers}
  217. if getregtype(left.location.register)<>R_ADDRESSREGISTER then
  218. begin
  219. location.reference.base:=rg.getaddressregister(exprasmlist);
  220. cg.a_load_reg_reg(exprasmlist,OS_ADDR,OS_ADDR,
  221. left.location.register,location.reference.base);
  222. end
  223. else
  224. {$endif}
  225. location.reference.base := left.location.register;
  226. end;
  227. LOC_CREFERENCE,
  228. LOC_REFERENCE:
  229. begin
  230. location.reference.base:=cg.getaddressregister(exprasmlist);
  231. cg.a_load_loc_reg(exprasmlist,OS_ADDR,left.location,location.reference.base);
  232. end;
  233. end;
  234. { implicit deferencing }
  235. if (cs_use_heaptrc in aktglobalswitches) and
  236. (cs_checkpointer in aktlocalswitches) and
  237. not(cs_compilesystem in aktmoduleswitches) then
  238. begin
  239. paramanager.getintparaloc(pocall_default,1,paraloc1);
  240. paramanager.allocparaloc(exprasmlist,paraloc1);
  241. cg.a_param_reg(exprasmlist, OS_ADDR,location.reference.base,paraloc1);
  242. paramanager.freeparaloc(exprasmlist,paraloc1);
  243. cg.allocallcpuregisters(exprasmlist);
  244. cg.a_call_name(exprasmlist,'FPC_CHECKPOINTER');
  245. cg.deallocallcpuregisters(exprasmlist);
  246. end;
  247. end
  248. else if is_interfacecom(left.resulttype.def) then
  249. begin
  250. location_reset(location,LOC_REFERENCE,def_cgsize(resulttype.def));
  251. tg.GetTempTyped(exprasmlist,left.resulttype.def,tt_normal,location.reference);
  252. cg.a_load_loc_ref(exprasmlist,OS_ADDR,left.location,location.reference);
  253. { implicit deferencing also for interfaces }
  254. if (cs_use_heaptrc in aktglobalswitches) and
  255. (cs_checkpointer in aktlocalswitches) and
  256. not(cs_compilesystem in aktmoduleswitches) then
  257. begin
  258. paramanager.getintparaloc(pocall_default,1,paraloc1);
  259. paramanager.allocparaloc(exprasmlist,paraloc1);
  260. cg.a_param_reg(exprasmlist, OS_ADDR,location.reference.base,paraloc1);
  261. paramanager.freeparaloc(exprasmlist,paraloc1);
  262. cg.allocallcpuregisters(exprasmlist);
  263. cg.a_call_name(exprasmlist,'FPC_CHECKPOINTER');
  264. cg.deallocallcpuregisters(exprasmlist);
  265. end;
  266. end
  267. else
  268. location_copy(location,left.location);
  269. inc(location.reference.offset,vs.fieldoffset);
  270. { also update the size of the location }
  271. location.size:=def_cgsize(resulttype.def);
  272. paraloc1.done;
  273. end;
  274. {*****************************************************************************
  275. TCGWITHNODE
  276. *****************************************************************************}
  277. procedure tcgwithnode.pass_2;
  278. begin
  279. location_reset(location,LOC_VOID,OS_NO);
  280. if assigned(left) then
  281. secondpass(left);
  282. end;
  283. {*****************************************************************************
  284. TCGVECNODE
  285. *****************************************************************************}
  286. function tcgvecnode.get_mul_size : aint;
  287. begin
  288. if nf_memindex in flags then
  289. get_mul_size:=1
  290. else
  291. begin
  292. if (left.resulttype.def.deftype=arraydef) then
  293. get_mul_size:=tarraydef(left.resulttype.def).elesize
  294. else
  295. get_mul_size:=resulttype.def.size;
  296. end
  297. end;
  298. procedure tcgvecnode.update_reference_reg_mul(reg:tregister;l:aint);
  299. var
  300. hreg: tregister;
  301. begin
  302. if location.reference.base=NR_NO then
  303. begin
  304. if l<>1 then
  305. cg.a_op_const_reg(exprasmlist,OP_IMUL,OS_ADDR,l,reg);
  306. location.reference.base:=reg;
  307. end
  308. else if location.reference.index=NR_NO then
  309. begin
  310. if l<>1 then
  311. cg.a_op_const_reg(exprasmlist,OP_IMUL,OS_ADDR,l,reg);
  312. location.reference.index:=reg;
  313. end
  314. else
  315. begin
  316. hreg := cg.getaddressregister(exprasmlist);
  317. cg.a_loadaddr_ref_reg(exprasmlist,location.reference,hreg);
  318. reference_reset_base(location.reference,hreg,0);
  319. { insert new index register }
  320. if l<>1 then
  321. cg.a_op_const_reg(exprasmlist,OP_IMUL,OS_ADDR,l,reg);
  322. location.reference.index:=reg;
  323. end;
  324. end;
  325. procedure tcgvecnode.second_wideansistring;
  326. begin
  327. end;
  328. procedure tcgvecnode.second_dynamicarray;
  329. begin
  330. end;
  331. procedure tcgvecnode.rangecheck_array;
  332. var
  333. hightree : tnode;
  334. poslabel,
  335. neglabel : tasmlabel;
  336. hreg : tregister;
  337. paraloc1,paraloc2 : tcgpara;
  338. begin
  339. paraloc1.init;
  340. paraloc2.init;
  341. if is_open_array(left.resulttype.def) or
  342. is_array_of_const(left.resulttype.def) then
  343. begin
  344. { cdecl functions don't have high() so we can not check the range }
  345. if not(current_procinfo.procdef.proccalloption in [pocall_cdecl,pocall_cppdecl]) then
  346. begin
  347. { Get high value }
  348. hightree:=load_high_value_node(tparavarsym(tloadnode(left).symtableentry));
  349. { it must be available }
  350. if not assigned(hightree) then
  351. internalerror(200212201);
  352. firstpass(hightree);
  353. secondpass(hightree);
  354. { generate compares }
  355. if (right.location.loc in [LOC_REGISTER,LOC_CREGISTER]) then
  356. hreg:=cg.makeregsize(exprasmlist,right.location.register,OS_INT)
  357. else
  358. begin
  359. hreg:=cg.getintregister(exprasmlist,OS_INT);
  360. cg.a_load_loc_reg(exprasmlist,OS_INT,right.location,hreg);
  361. end;
  362. objectlibrary.getjumplabel(neglabel);
  363. objectlibrary.getjumplabel(poslabel);
  364. cg.a_cmp_const_reg_label(exprasmlist,OS_INT,OC_LT,0,hreg,poslabel);
  365. cg.a_cmp_loc_reg_label(exprasmlist,OS_INT,OC_BE,hightree.location,hreg,neglabel);
  366. cg.a_label(exprasmlist,poslabel);
  367. cg.a_call_name(exprasmlist,'FPC_RANGEERROR');
  368. cg.a_label(exprasmlist,neglabel);
  369. { release hightree }
  370. hightree.free;
  371. end;
  372. end
  373. else
  374. if is_dynamic_array(left.resulttype.def) then
  375. begin
  376. paramanager.getintparaloc(pocall_default,1,paraloc1);
  377. paramanager.getintparaloc(pocall_default,2,paraloc2);
  378. paramanager.allocparaloc(exprasmlist,paraloc2);
  379. cg.a_param_loc(exprasmlist,right.location,paraloc2);
  380. paramanager.allocparaloc(exprasmlist,paraloc1);
  381. cg.a_param_loc(exprasmlist,left.location,paraloc1);
  382. paramanager.freeparaloc(exprasmlist,paraloc1);
  383. paramanager.freeparaloc(exprasmlist,paraloc2);
  384. cg.allocallcpuregisters(exprasmlist);
  385. cg.a_call_name(exprasmlist,'FPC_DYNARRAY_RANGECHECK');
  386. cg.deallocallcpuregisters(exprasmlist);
  387. end
  388. else
  389. cg.g_rangecheck(exprasmlist,right.location,right.resulttype.def,left.resulttype.def);
  390. paraloc1.done;
  391. paraloc2.done;
  392. end;
  393. procedure tcgvecnode.pass_2;
  394. var
  395. offsetdec,
  396. extraoffset : aint;
  397. t : tnode;
  398. href : treference;
  399. otl,ofl : tasmlabel;
  400. newsize : tcgsize;
  401. mulsize : aint;
  402. isjump : boolean;
  403. paraloc1,
  404. paraloc2 : tcgpara;
  405. begin
  406. paraloc1.init;
  407. paraloc2.init;
  408. mulsize := get_mul_size;
  409. newsize:=def_cgsize(resulttype.def);
  410. secondpass(left);
  411. if left.location.loc=LOC_CREFERENCE then
  412. location_reset(location,LOC_CREFERENCE,newsize)
  413. else
  414. location_reset(location,LOC_REFERENCE,newsize);
  415. { an ansistring needs to be dereferenced }
  416. if is_ansistring(left.resulttype.def) or
  417. is_widestring(left.resulttype.def) then
  418. begin
  419. if nf_callunique in flags then
  420. internalerror(200304236);
  421. {DM!!!!!}
  422. case left.location.loc of
  423. LOC_REGISTER,
  424. LOC_CREGISTER :
  425. location.reference.base:=left.location.register;
  426. LOC_CREFERENCE,
  427. LOC_REFERENCE :
  428. begin
  429. location.reference.base:=cg.getaddressregister(exprasmlist);
  430. cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.reference,location.reference.base);
  431. end;
  432. else
  433. internalerror(2002032218);
  434. end;
  435. { check for a zero length string,
  436. we can use the ansistring routine here }
  437. if (cs_check_range in aktlocalswitches) then
  438. begin
  439. paramanager.getintparaloc(pocall_default,1,paraloc1);
  440. paramanager.allocparaloc(exprasmlist,paraloc1);
  441. cg.a_param_reg(exprasmlist,OS_ADDR,location.reference.base,paraloc1);
  442. paramanager.freeparaloc(exprasmlist,paraloc1);
  443. cg.allocallcpuregisters(exprasmlist);
  444. cg.a_call_name(exprasmlist,'FPC_'+upper(tstringdef(left.resulttype.def).stringtypname)+'_CHECKZERO');
  445. cg.deallocallcpuregisters(exprasmlist);
  446. end;
  447. { in ansistrings/widestrings S[1] is p<w>char(S)[0] !! }
  448. if is_ansistring(left.resulttype.def) then
  449. offsetdec:=1
  450. else
  451. offsetdec:=2;
  452. dec(location.reference.offset,offsetdec);
  453. end
  454. else if is_dynamic_array(left.resulttype.def) then
  455. begin
  456. case left.location.loc of
  457. LOC_REGISTER,
  458. LOC_CREGISTER :
  459. location.reference.base:=left.location.register;
  460. LOC_REFERENCE,
  461. LOC_CREFERENCE :
  462. begin
  463. location.reference.base:=cg.getaddressregister(exprasmlist);
  464. cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,
  465. left.location.reference,location.reference.base);
  466. end;
  467. else
  468. internalerror(2002032219);
  469. end;
  470. end
  471. else
  472. location_copy(location,left.location);
  473. { location must be memory }
  474. if not(location.loc in [LOC_REFERENCE,LOC_CREFERENCE]) then
  475. internalerror(200411013);
  476. { offset can only differ from 0 if arraydef }
  477. if (left.resulttype.def.deftype=arraydef) and
  478. not(is_dynamic_array(left.resulttype.def)) then
  479. dec(location.reference.offset,mulsize*tarraydef(left.resulttype.def).lowrange);
  480. if right.nodetype=ordconstn then
  481. begin
  482. { offset can only differ from 0 if arraydef }
  483. case left.resulttype.def.deftype of
  484. arraydef :
  485. begin
  486. if not(is_open_array(left.resulttype.def)) and
  487. not(is_array_of_const(left.resulttype.def)) and
  488. not(is_dynamic_array(left.resulttype.def)) then
  489. begin
  490. if (tordconstnode(right).value>tarraydef(left.resulttype.def).highrange) or
  491. (tordconstnode(right).value<tarraydef(left.resulttype.def).lowrange) then
  492. begin
  493. { this should be caught in the resulttypepass! (JM) }
  494. if (cs_check_range in aktlocalswitches) then
  495. CGMessage(parser_e_range_check_error)
  496. else
  497. CGMessage(parser_w_range_check_error);
  498. end;
  499. end
  500. else
  501. begin
  502. { range checking for open and dynamic arrays needs
  503. runtime code }
  504. secondpass(right);
  505. if (cs_check_range in aktlocalswitches) then
  506. rangecheck_array;
  507. end;
  508. end;
  509. stringdef :
  510. begin
  511. if (cs_check_range in aktlocalswitches) then
  512. begin
  513. case tstringdef(left.resulttype.def).string_typ of
  514. { it's the same for ansi- and wide strings }
  515. st_widestring,
  516. st_ansistring:
  517. begin
  518. paramanager.getintparaloc(pocall_default,1,paraloc1);
  519. paramanager.getintparaloc(pocall_default,2,paraloc2);
  520. paramanager.allocparaloc(exprasmlist,paraloc2);
  521. cg.a_param_const(exprasmlist,OS_INT,tordconstnode(right).value,paraloc2);
  522. href:=location.reference;
  523. dec(href.offset,sizeof(aint)-offsetdec);
  524. paramanager.allocparaloc(exprasmlist,paraloc1);
  525. cg.a_param_ref(exprasmlist,OS_INT,href,paraloc1);
  526. paramanager.freeparaloc(exprasmlist,paraloc1);
  527. paramanager.freeparaloc(exprasmlist,paraloc2);
  528. cg.allocallcpuregisters(exprasmlist);
  529. cg.a_call_name(exprasmlist,'FPC_'+upper(tstringdef(left.resulttype.def).stringtypname)+'_RANGECHECK');
  530. cg.deallocallcpuregisters(exprasmlist);
  531. end;
  532. st_shortstring:
  533. begin
  534. {!!!!!!!!!!!!!!!!!}
  535. end;
  536. st_longstring:
  537. begin
  538. {!!!!!!!!!!!!!!!!!}
  539. end;
  540. end;
  541. end;
  542. end;
  543. end;
  544. inc(location.reference.offset,
  545. mulsize*tordconstnode(right).value);
  546. end
  547. else
  548. { not nodetype=ordconstn }
  549. begin
  550. if (cs_opt_regvar in aktoptimizerswitches) and
  551. { if we do range checking, we don't }
  552. { need that fancy code (it would be }
  553. { buggy) }
  554. not(cs_check_range in aktlocalswitches) and
  555. (left.resulttype.def.deftype=arraydef) then
  556. begin
  557. extraoffset:=0;
  558. if (right.nodetype=addn) then
  559. begin
  560. if taddnode(right).right.nodetype=ordconstn then
  561. begin
  562. extraoffset:=tordconstnode(taddnode(right).right).value;
  563. t:=taddnode(right).left;
  564. { First pass processed this with the assumption }
  565. { that there was an add node which may require an }
  566. { extra register. Fake it or die with IE10 (JM) }
  567. t.registersint := taddnode(right).registersint;
  568. taddnode(right).left:=nil;
  569. right.free;
  570. right:=t;
  571. end
  572. else if taddnode(right).left.nodetype=ordconstn then
  573. begin
  574. extraoffset:=tordconstnode(taddnode(right).left).value;
  575. t:=taddnode(right).right;
  576. t.registersint := right.registersint;
  577. taddnode(right).right:=nil;
  578. right.free;
  579. right:=t;
  580. end;
  581. end
  582. else if (right.nodetype=subn) then
  583. begin
  584. if taddnode(right).right.nodetype=ordconstn then
  585. begin
  586. extraoffset:=-tordconstnode(taddnode(right).right).value;
  587. t:=taddnode(right).left;
  588. t.registersint := right.registersint;
  589. taddnode(right).left:=nil;
  590. right.free;
  591. right:=t;
  592. end
  593. { You also have to negate right.right in this case! I can't add an
  594. unaryminusn without causing a crash, so I've disabled it (JM)
  595. else if right.left.nodetype=ordconstn then
  596. begin
  597. extraoffset:=right.left.value;
  598. t:=right.right;
  599. t^.registersint := right.registersint;
  600. putnode(right);
  601. putnode(right.left);
  602. right:=t;
  603. end;}
  604. end;
  605. inc(location.reference.offset,
  606. mulsize*extraoffset);
  607. end;
  608. { calculate from left to right }
  609. if not(location.loc in [LOC_CREFERENCE,LOC_REFERENCE]) then
  610. internalerror(200304237);
  611. isjump:=(right.expectloc=LOC_JUMP);
  612. if isjump then
  613. begin
  614. otl:=truelabel;
  615. objectlibrary.getjumplabel(truelabel);
  616. ofl:=falselabel;
  617. objectlibrary.getjumplabel(falselabel);
  618. end;
  619. secondpass(right);
  620. { if mulsize = 1, we won't have to modify the index }
  621. location_force_reg(exprasmlist,right.location,OS_ADDR,(mulsize = 1));
  622. if isjump then
  623. begin
  624. truelabel:=otl;
  625. falselabel:=ofl;
  626. end
  627. else if (right.location.loc = LOC_JUMP) then
  628. internalerror(2006010801);
  629. { only range check now, we can't range check loc_flags/loc_jump }
  630. if cs_check_range in aktlocalswitches then
  631. begin
  632. if left.resulttype.def.deftype=arraydef then
  633. rangecheck_array;
  634. end;
  635. { produce possible range check code: }
  636. if cs_check_range in aktlocalswitches then
  637. begin
  638. if left.resulttype.def.deftype=arraydef then
  639. begin
  640. { done defore (PM) }
  641. end
  642. else if (left.resulttype.def.deftype=stringdef) then
  643. begin
  644. case tstringdef(left.resulttype.def).string_typ of
  645. { it's the same for ansi- and wide strings }
  646. st_widestring,
  647. st_ansistring:
  648. begin
  649. paramanager.getintparaloc(pocall_default,1,paraloc1);
  650. paramanager.getintparaloc(pocall_default,2,paraloc2);
  651. paramanager.allocparaloc(exprasmlist,paraloc2);
  652. cg.a_param_reg(exprasmlist,OS_INT,right.location.register,paraloc2);
  653. href:=location.reference;
  654. dec(href.offset,sizeof(aint)-offsetdec);
  655. //dec(href.offset,7);
  656. paramanager.allocparaloc(exprasmlist,paraloc1);
  657. cg.a_param_ref(exprasmlist,OS_INT,href,paraloc1);
  658. paramanager.freeparaloc(exprasmlist,paraloc1);
  659. paramanager.freeparaloc(exprasmlist,paraloc2);
  660. cg.allocallcpuregisters(exprasmlist);
  661. cg.a_call_name(exprasmlist,'FPC_'+upper(tstringdef(left.resulttype.def).stringtypname)+'_RANGECHECK');
  662. cg.deallocallcpuregisters(exprasmlist);
  663. end;
  664. st_shortstring:
  665. begin
  666. {!!!!!!!!!!!!!!!!!}
  667. end;
  668. st_longstring:
  669. begin
  670. {!!!!!!!!!!!!!!!!!}
  671. end;
  672. end;
  673. end;
  674. end;
  675. { insert the register and the multiplication factor in the
  676. reference }
  677. update_reference_reg_mul(right.location.register,mulsize);
  678. end;
  679. location.size:=newsize;
  680. paraloc1.done;
  681. paraloc2.done;
  682. end;
  683. begin
  684. cloadvmtaddrnode:=tcgloadvmtaddrnode;
  685. cloadparentfpnode:=tcgloadparentfpnode;
  686. caddrnode:=tcgaddrnode;
  687. cderefnode:=tcgderefnode;
  688. csubscriptnode:=tcgsubscriptnode;
  689. cwithnode:=tcgwithnode;
  690. cvecnode:=tcgvecnode;
  691. end.