n386ld.pas 51 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168
  1. {
  2. $Id$
  3. Copyright (c) 1998-2000 by Florian Klaempfl
  4. Generate i386 assembler for load/assignment nodes
  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 n386ld;
  19. {$i defines.inc}
  20. interface
  21. uses
  22. node,nld;
  23. type
  24. ti386loadnode = class(tloadnode)
  25. procedure pass_2;override;
  26. end;
  27. ti386assignmentnode = class(tassignmentnode)
  28. procedure pass_2;override;
  29. end;
  30. ti386funcretnode = class(tfuncretnode)
  31. procedure pass_2;override;
  32. end;
  33. ti386arrayconstructornode = class(tarrayconstructornode)
  34. procedure pass_2;override;
  35. end;
  36. implementation
  37. uses
  38. systems,
  39. verbose,globals,
  40. symconst,symtype,symdef,symsym,symtable,aasm,types,
  41. cgbase,temp_gen,pass_2,
  42. nmem,ncon,ncnv,
  43. cpubase,cpuasm,
  44. cga,tgcpu,n386cnv,n386util,regvars;
  45. {*****************************************************************************
  46. SecondLoad
  47. *****************************************************************************}
  48. procedure ti386loadnode.pass_2;
  49. var
  50. hregister : tregister;
  51. symtabletype : tsymtabletype;
  52. i : longint;
  53. hp : preference;
  54. s : tasmsymbol;
  55. popeax : boolean;
  56. //pushed : tpushed;
  57. //hr : treference;
  58. begin
  59. simple_loadn:=true;
  60. reset_reference(location.reference);
  61. case symtableentry.typ of
  62. { this is only for toasm and toaddr }
  63. absolutesym :
  64. begin
  65. location.reference.symbol:=nil;
  66. if (tabsolutesym(symtableentry).abstyp=toaddr) then
  67. begin
  68. if tabsolutesym(symtableentry).absseg then
  69. location.reference.segment:=R_FS;
  70. location.reference.offset:=tabsolutesym(symtableentry).address;
  71. end
  72. else
  73. location.reference.symbol:=newasmsymbol(symtableentry.mangledname);
  74. end;
  75. constsym:
  76. begin
  77. if tconstsym(symtableentry).consttyp=constresourcestring then
  78. begin
  79. location.loc:=LOC_MEM;
  80. location.reference.symbol:=newasmsymbol(tconstsym(symtableentry).owner.name^+'_RESOURCESTRINGLIST');
  81. location.reference.offset:=tconstsym(symtableentry).resstrindex*16+8;
  82. end
  83. else
  84. internalerror(22798);
  85. end;
  86. varsym :
  87. begin
  88. hregister:=R_NO;
  89. { C variable }
  90. if (vo_is_C_var in tvarsym(symtableentry).varoptions) then
  91. begin
  92. location.reference.symbol:=newasmsymbol(symtableentry.mangledname);
  93. end
  94. { DLL variable }
  95. else if (vo_is_dll_var in tvarsym(symtableentry).varoptions) then
  96. begin
  97. hregister:=getregister32;
  98. location.reference.symbol:=newasmsymbol(symtableentry.mangledname);
  99. emit_ref_reg(A_MOV,S_L,newreference(location.reference),hregister);
  100. location.reference.symbol:=nil;
  101. location.reference.base:=hregister;
  102. end
  103. { external variable }
  104. else if (vo_is_external in tvarsym(symtableentry).varoptions) then
  105. begin
  106. location.reference.symbol:=newasmsymbol(symtableentry.mangledname);
  107. end
  108. { thread variable }
  109. else if (vo_is_thread_var in tvarsym(symtableentry).varoptions) then
  110. begin
  111. popeax:=not(R_EAX in unused);
  112. if popeax then
  113. emit_reg(A_PUSH,S_L,R_EAX);
  114. location.reference.symbol:=newasmsymbol(symtableentry.mangledname);
  115. emit_ref(A_PUSH,S_L,newreference(location.reference));
  116. { the called procedure isn't allowed to change }
  117. { any register except EAX }
  118. emitcall('FPC_RELOCATE_THREADVAR');
  119. reset_reference(location.reference);
  120. location.reference.base:=getregister32;
  121. emit_reg_reg(A_MOV,S_L,R_EAX,location.reference.base);
  122. if popeax then
  123. emit_reg(A_POP,S_L,R_EAX);
  124. end
  125. { normal variable }
  126. else
  127. begin
  128. symtabletype:=symtable.symtabletype;
  129. { in case it is a register variable: }
  130. if tvarsym(symtableentry).reg<>R_NO then
  131. begin
  132. if tvarsym(symtableentry).reg in [R_ST0..R_ST7] then
  133. begin
  134. location.loc:=LOC_CFPUREGISTER;
  135. location.register:=tvarsym(symtableentry).reg;
  136. end
  137. else
  138. if not(makereg32(tvarsym(symtableentry).reg) in [R_EAX..R_EBX]) or
  139. regvar_loaded[tvarsym(symtableentry).reg] then
  140. begin
  141. location.loc:=LOC_CREGISTER;
  142. location.register:=tvarsym(symtableentry).reg;
  143. unused:=unused-[tvarsym(symtableentry).reg];
  144. end
  145. else
  146. begin
  147. load_regvar(exprasmlist,tvarsym(symtableentry));
  148. location.loc:=LOC_CREGISTER;
  149. location.register:=tvarsym(symtableentry).reg;
  150. unused:=unused-[tvarsym(symtableentry).reg];
  151. end
  152. end
  153. else
  154. begin
  155. { first handle local and temporary variables }
  156. if (symtabletype in [parasymtable,inlinelocalsymtable,
  157. inlineparasymtable,localsymtable]) then
  158. begin
  159. location.reference.base:=procinfo^.framepointer;
  160. if (symtabletype in [inlinelocalsymtable,
  161. localsymtable]) then
  162. location.reference.offset:=
  163. tvarsym(symtableentry).address-symtable.address_fixup
  164. else
  165. location.reference.offset:=
  166. tvarsym(symtableentry).address+symtable.address_fixup;
  167. if (symtabletype in [localsymtable,inlinelocalsymtable]) then
  168. begin
  169. if use_esp_stackframe then
  170. dec(location.reference.offset,
  171. tvarsym(symtableentry).getvaluesize)
  172. else
  173. location.reference.offset:=-location.reference.offset;
  174. end;
  175. if (lexlevel>(symtable.symtablelevel)) then
  176. begin
  177. hregister:=getregister32;
  178. { make a reference }
  179. hp:=new_reference(procinfo^.framepointer,
  180. procinfo^.framepointer_offset);
  181. emit_ref_reg(A_MOV,S_L,hp,hregister);
  182. simple_loadn:=false;
  183. i:=lexlevel-1;
  184. while i>(symtable.symtablelevel) do
  185. begin
  186. { make a reference }
  187. hp:=new_reference(hregister,8);
  188. emit_ref_reg(A_MOV,S_L,hp,hregister);
  189. dec(i);
  190. end;
  191. location.reference.base:=hregister;
  192. end;
  193. end
  194. else
  195. case symtabletype of
  196. globalsymtable,
  197. staticsymtable :
  198. begin
  199. location.reference.symbol:=newasmsymbol(symtableentry.mangledname);
  200. end;
  201. stt_exceptsymtable:
  202. begin
  203. location.reference.base:=procinfo^.framepointer;
  204. location.reference.offset:=tvarsym(symtableentry).address;
  205. end;
  206. objectsymtable:
  207. begin
  208. getexplicitregister32(R_ESI);
  209. if (sp_static in tvarsym(symtableentry).symoptions) then
  210. begin
  211. location.reference.symbol:=newasmsymbol(symtableentry.mangledname);
  212. end
  213. else
  214. begin
  215. location.reference.base:=R_ESI;
  216. location.reference.offset:=tvarsym(symtableentry).address;
  217. end;
  218. end;
  219. withsymtable:
  220. begin
  221. { make a reference }
  222. { symtable datasize field
  223. contains the offset of the temp
  224. stored }
  225. { hp:=new_reference(procinfo^.framepointer,
  226. symtable.datasize);
  227. emit_ref_reg(A_MOV,S_L,hp,hregister);}
  228. if nf_islocal in tnode(twithsymtable(symtable).withnode).flags then
  229. begin
  230. location.reference:=twithnode(twithsymtable(symtable).withnode).withreference^;
  231. end
  232. else
  233. begin
  234. hregister:=getregister32;
  235. location.reference.base:=hregister;
  236. emit_ref_reg(A_MOV,S_L,
  237. newreference(twithnode(twithsymtable(symtable).withnode).withreference^),
  238. hregister);
  239. end;
  240. inc(location.reference.offset,tvarsym(symtableentry).address);
  241. end;
  242. end;
  243. end;
  244. { in case call by reference, then calculate. Open array
  245. is always an reference! }
  246. if (tvarsym(symtableentry).varspez in [vs_var,vs_out]) or
  247. is_open_array(tvarsym(symtableentry).vartype.def) or
  248. is_array_of_const(tvarsym(symtableentry).vartype.def) or
  249. ((tvarsym(symtableentry).varspez=vs_const) and
  250. push_addr_param(tvarsym(symtableentry).vartype.def)) then
  251. begin
  252. simple_loadn:=false;
  253. if hregister=R_NO then
  254. hregister:=getregister32;
  255. if location.loc=LOC_CREGISTER then
  256. begin
  257. emit_reg_reg(A_MOV,S_L,
  258. location.register,hregister);
  259. location.loc:=LOC_REFERENCE;
  260. end
  261. else
  262. begin
  263. emit_ref_reg(A_MOV,S_L,
  264. newreference(location.reference),
  265. hregister);
  266. end;
  267. reset_reference(location.reference);
  268. location.reference.base:=hregister;
  269. end;
  270. end;
  271. end;
  272. procsym:
  273. begin
  274. if assigned(left) then
  275. begin
  276. location.loc:=LOC_MEM;
  277. gettempofsizereference(8,location.reference);
  278. if left.nodetype=typen then
  279. begin
  280. if left.resulttype.def.deftype<>objectdef then
  281. internalerror(200103261);
  282. getexplicitregister32(R_EDI);
  283. hregister:=R_EDI;
  284. new(hp);
  285. emit_sym_ofs_reg(A_MOV,S_L,
  286. newasmsymbol(tobjectdef(left.resulttype.def).vmt_mangledname),0,R_EDI);
  287. end
  288. else
  289. begin
  290. secondpass(left);
  291. { load class instance address }
  292. case left.location.loc of
  293. LOC_CREGISTER,
  294. LOC_REGISTER:
  295. begin
  296. hregister:=left.location.register;
  297. ungetregister32(left.location.register);
  298. if is_object(left.resulttype.def) then
  299. CGMessage(cg_e_illegal_expression);
  300. end;
  301. LOC_MEM,
  302. LOC_REFERENCE:
  303. begin
  304. getexplicitregister32(R_EDI);
  305. hregister:=R_EDI;
  306. if is_class_or_interface(left.resulttype.def) then
  307. emit_ref_reg(A_MOV,S_L,
  308. newreference(left.location.reference),R_EDI)
  309. else
  310. emit_ref_reg(A_LEA,S_L,
  311. newreference(left.location.reference),R_EDI);
  312. del_reference(left.location.reference);
  313. ungetiftemp(left.location.reference);
  314. end;
  315. else internalerror(26019);
  316. end;
  317. end;
  318. { store the class instance address }
  319. new(hp);
  320. hp^:=location.reference;
  321. inc(hp^.offset,4);
  322. emit_reg_ref(A_MOV,S_L,
  323. hregister,hp);
  324. { virtual method ? }
  325. if (po_virtualmethod in tprocsym(symtableentry).definition.procoptions) then
  326. begin
  327. new(hp);
  328. reset_reference(hp^);
  329. hp^.base:=hregister;
  330. { load vmt pointer }
  331. emit_ref_reg(A_MOV,S_L,
  332. hp,R_EDI);
  333. {$IfDef regallocfix}
  334. del_reference(hp^);
  335. {$EndIf regallocfix}
  336. { load method address }
  337. new(hp);
  338. reset_reference(hp^);
  339. hp^.base:=R_EDI;
  340. hp^.offset:=tprocsym(symtableentry).definition._class.vmtmethodoffset(
  341. tprocsym(symtableentry).definition.extnumber);
  342. emit_ref_reg(A_MOV,S_L,
  343. hp,R_EDI);
  344. { ... and store it }
  345. emit_reg_ref(A_MOV,S_L,
  346. R_EDI,newreference(location.reference));
  347. ungetregister32(R_EDI);
  348. end
  349. else
  350. begin
  351. ungetregister32(R_EDI);
  352. s:=newasmsymbol(tprocsym(symtableentry).definition.mangledname);
  353. emit_sym_ofs_ref(A_MOV,S_L,s,0,
  354. newreference(location.reference));
  355. end;
  356. end
  357. else
  358. begin
  359. {!!!!! Be aware, work on virtual methods too }
  360. location.reference.symbol:=newasmsymbol(tprocsym(symtableentry).definition.mangledname);
  361. end;
  362. end;
  363. typedconstsym :
  364. begin
  365. location.reference.symbol:=newasmsymbol(symtableentry.mangledname);
  366. end;
  367. else internalerror(4);
  368. end;
  369. end;
  370. {*****************************************************************************
  371. SecondAssignment
  372. *****************************************************************************}
  373. procedure ti386assignmentnode.pass_2;
  374. var
  375. opsize : topsize;
  376. otlabel,hlabel,oflabel : tasmlabel;
  377. fputyp : tfloattype;
  378. loc : tloc;
  379. r : preference;
  380. ai : taicpu;
  381. op : tasmop;
  382. pushed : boolean;
  383. regspushed : tpushed;
  384. regs_to_push: byte;
  385. ungettemp : boolean;
  386. begin
  387. otlabel:=truelabel;
  388. oflabel:=falselabel;
  389. getlabel(truelabel);
  390. getlabel(falselabel);
  391. { calculate left sides }
  392. { don't do it yet if it's a crgister (JM) }
  393. if not(nf_concat_string in flags) then
  394. secondpass(left);
  395. if codegenerror then
  396. exit;
  397. if not(left.location.loc in [LOC_REFERENCE,LOC_CFPUREGISTER,
  398. LOC_CREGISTER,LOC_CMMXREGISTER]) then
  399. begin
  400. CGMessage(cg_e_illegal_expression);
  401. exit;
  402. end;
  403. loc:=left.location.loc;
  404. { lets try to optimize this (PM) }
  405. { define a dest_loc that is the location }
  406. { and a ptree to verify that it is the right }
  407. { place to insert it }
  408. {$ifdef test_dest_loc}
  409. if (aktexprlevel<4) then
  410. begin
  411. dest_loc_known:=true;
  412. dest_loc:=left.location;
  413. dest_loc_tree:=right;
  414. end;
  415. {$endif test_dest_loc}
  416. { left can't be never a 64 bit LOC_REGISTER, so the 3. arg }
  417. { can be false }
  418. pushed:=maybe_push(right.registers32,left,false);
  419. secondpass(right);
  420. { restoring here is nonsense for LOC_JMP !! }
  421. { This generated code that was after a jmp and before any
  422. label => unreachable !!
  423. Could this be tested somehow ?? PM }
  424. if pushed and (right.location.loc <>LOC_JUMP) then
  425. restore(left,false);
  426. if codegenerror then
  427. exit;
  428. {$ifdef test_dest_loc}
  429. dest_loc_known:=false;
  430. if in_dest_loc then
  431. begin
  432. truelabel:=otlabel;
  433. falselabel:=oflabel;
  434. in_dest_loc:=false;
  435. exit;
  436. end;
  437. {$endif test_dest_loc}
  438. if left.resulttype.def.deftype=stringdef then
  439. begin
  440. if is_ansistring(left.resulttype.def) or
  441. is_widestring(left.resulttype.def) then
  442. begin
  443. { before pushing any parameter, we have to save all used }
  444. { registers, but before that we have to release the }
  445. { registers of that node to save uneccessary pushed }
  446. { so be careful, if you think you can optimize that code (FK) }
  447. { nevertheless, this has to be changed, because otherwise the }
  448. { register is released before it's contents are pushed -> }
  449. { problems with the optimizer (JM) }
  450. ungettemp:=false;
  451. { Find out which registers have to be pushed (JM) }
  452. regs_to_push := $ff;
  453. remove_non_regvars_from_loc(right.location,regs_to_push);
  454. remove_non_regvars_from_loc(left.location,regs_to_push);
  455. { And push them (JM) }
  456. pushusedregisters(regspushed,regs_to_push);
  457. case right.location.loc of
  458. LOC_REGISTER,LOC_CREGISTER:
  459. begin
  460. exprasmList.concat(Taicpu.Op_reg(A_PUSH,S_L,right.location.register));
  461. ungetregister32(right.location.register);
  462. end;
  463. LOC_REFERENCE,LOC_MEM:
  464. begin
  465. { First release the registers because emit_push_mem may }
  466. { load the reference in edi before pushing and then the }
  467. { dealloc is too late (and optimizations are missed (JM) }
  468. del_reference(right.location.reference);
  469. { This one doesn't need extra registers (JM) }
  470. emit_push_mem(right.location.reference);
  471. ungettemp:=true;
  472. end;
  473. end;
  474. emitpushreferenceaddr(left.location.reference);
  475. del_reference(left.location.reference);
  476. saveregvars($ff);
  477. if is_ansistring(left.resulttype.def) then
  478. emitcall('FPC_ANSISTR_ASSIGN')
  479. else
  480. emitcall('FPC_WIDESTR_ASSIGN');
  481. maybe_loadself;
  482. popusedregisters(regspushed);
  483. if ungettemp then
  484. ungetiftemp(right.location.reference);
  485. end
  486. else
  487. if is_shortstring(left.resulttype.def) and
  488. not (nf_concat_string in flags) then
  489. begin
  490. if is_ansistring(right.resulttype.def) then
  491. begin
  492. if (right.nodetype=stringconstn) and
  493. (tstringconstnode(right).len=0) then
  494. begin
  495. emit_const_ref(A_MOV,S_B,
  496. 0,newreference(left.location.reference));
  497. del_reference(left.location.reference);
  498. end
  499. else
  500. loadansi2short(right,left);
  501. end
  502. else
  503. begin
  504. { we do not need destination anymore }
  505. del_reference(left.location.reference);
  506. {del_reference(right.location.reference);
  507. done in loadshortstring }
  508. loadshortstring(right,left);
  509. ungetiftemp(right.location.reference);
  510. end;
  511. end
  512. else if is_longstring(left.resulttype.def) then
  513. begin
  514. internalerror(200105261);
  515. end
  516. else
  517. begin
  518. { its the only thing we have to do }
  519. del_reference(right.location.reference);
  520. end
  521. end
  522. else if is_interfacecom(left.resulttype.def) then
  523. begin
  524. loadinterfacecom(self);
  525. end
  526. else case right.location.loc of
  527. LOC_REFERENCE,
  528. LOC_MEM : begin
  529. { extra handling for ordinal constants }
  530. if (right.nodetype in [ordconstn,pointerconstn,niln]) or
  531. (loc=LOC_CREGISTER) then
  532. begin
  533. case left.resulttype.def.size of
  534. 1 : opsize:=S_B;
  535. 2 : opsize:=S_W;
  536. 4 : opsize:=S_L;
  537. { S_L is correct, the copy is done }
  538. { with two moves }
  539. 8 : opsize:=S_L;
  540. end;
  541. if loc=LOC_CREGISTER then
  542. begin
  543. emit_ref_reg(A_MOV,opsize,
  544. newreference(right.location.reference),
  545. left.location.register);
  546. if left.resulttype.def.size=8 then
  547. begin
  548. r:=newreference(right.location.reference);
  549. inc(r^.offset,4);
  550. emit_ref_reg(A_MOV,opsize,r,
  551. left.location.registerhigh);
  552. end;
  553. {$IfDef regallocfix}
  554. del_reference(right.location.reference);
  555. {$EndIf regallocfix}
  556. end
  557. else
  558. begin
  559. if left.resulttype.def.size=8 then
  560. begin
  561. emit_const_ref(A_MOV,opsize,
  562. longint(lo(tordconstnode(right).value)),
  563. newreference(left.location.reference));
  564. r:=newreference(left.location.reference);
  565. inc(r^.offset,4);
  566. emit_const_ref(A_MOV,opsize,
  567. longint(hi(tordconstnode(right).value)),r);
  568. end
  569. else
  570. begin
  571. emit_const_ref(A_MOV,opsize,
  572. right.location.reference.offset,
  573. newreference(left.location.reference));
  574. end;
  575. {$IfDef regallocfix}
  576. del_reference(left.location.reference);
  577. {$EndIf regallocfix}
  578. {emit_const_loc(A_MOV,opsize,
  579. right.location.reference.offset,
  580. left.location);}
  581. end;
  582. end
  583. else if loc=LOC_CFPUREGISTER then
  584. begin
  585. floatloadops(tfloatdef(right.resulttype.def).typ,op,opsize);
  586. emit_ref(op,opsize,
  587. newreference(right.location.reference));
  588. emit_reg(A_FSTP,S_NO,
  589. correct_fpuregister(left.location.register,fpuvaroffset+1));
  590. end
  591. else
  592. begin
  593. if (right.resulttype.def.needs_inittable) then
  594. begin
  595. { this would be a problem }
  596. if not(left.resulttype.def.needs_inittable) then
  597. internalerror(3457);
  598. { increment source reference counter }
  599. new(r);
  600. reset_reference(r^);
  601. r^.symbol:=tstoreddef(right.resulttype.def).get_rtti_label(initrtti);
  602. emitpushreferenceaddr(r^);
  603. emitpushreferenceaddr(right.location.reference);
  604. emitcall('FPC_ADDREF');
  605. { decrement destination reference counter }
  606. new(r);
  607. reset_reference(r^);
  608. r^.symbol:=tstoreddef(left.resulttype.def).get_rtti_label(initrtti);
  609. emitpushreferenceaddr(r^);
  610. emitpushreferenceaddr(left.location.reference);
  611. emitcall('FPC_DECREF');
  612. end;
  613. {$ifdef regallocfix}
  614. concatcopy(right.location.reference,
  615. left.location.reference,left.resulttype.def.size,true,false);
  616. ungetiftemp(right.location.reference);
  617. {$Else regallocfix}
  618. concatcopy(right.location.reference,
  619. left.location.reference,left.resulttype.def.size,false,false);
  620. ungetiftemp(right.location.reference);
  621. {$endif regallocfix}
  622. end;
  623. end;
  624. {$ifdef SUPPORT_MMX}
  625. LOC_CMMXREGISTER,
  626. LOC_MMXREGISTER:
  627. begin
  628. if loc=LOC_CMMXREGISTER then
  629. emit_reg_reg(A_MOVQ,S_NO,
  630. right.location.register,left.location.register)
  631. else
  632. emit_reg_ref(A_MOVQ,S_NO,
  633. right.location.register,newreference(left.location.reference));
  634. end;
  635. {$endif SUPPORT_MMX}
  636. LOC_REGISTER,
  637. LOC_CREGISTER : begin
  638. case right.resulttype.def.size of
  639. 1 : opsize:=S_B;
  640. 2 : opsize:=S_W;
  641. 4 : opsize:=S_L;
  642. 8 : opsize:=S_L;
  643. end;
  644. { simplified with op_reg_loc }
  645. if loc=LOC_CREGISTER then
  646. begin
  647. emit_reg_reg(A_MOV,opsize,
  648. right.location.register,
  649. left.location.register);
  650. ungetregister(right.location.register);
  651. end
  652. else
  653. Begin
  654. emit_reg_ref(A_MOV,opsize,
  655. right.location.register,
  656. newreference(left.location.reference));
  657. ungetregister(right.location.register);
  658. {$IfDef regallocfix}
  659. del_reference(left.location.reference);
  660. {$EndIf regallocfix}
  661. end;
  662. if is_64bitint(right.resulttype.def) then
  663. begin
  664. { simplified with op_reg_loc }
  665. if loc=LOC_CREGISTER then
  666. emit_reg_reg(A_MOV,opsize,
  667. right.location.registerhigh,
  668. left.location.registerhigh)
  669. else
  670. begin
  671. r:=newreference(left.location.reference);
  672. inc(r^.offset,4);
  673. emit_reg_ref(A_MOV,opsize,
  674. right.location.registerhigh,r);
  675. end;
  676. end;
  677. {emit_reg_loc(A_MOV,opsize,
  678. right.location.register,
  679. left.location); }
  680. end;
  681. LOC_FPU : begin
  682. if (left.resulttype.def.deftype=floatdef) then
  683. fputyp:=tfloatdef(left.resulttype.def).typ
  684. else
  685. if (right.resulttype.def.deftype=floatdef) then
  686. fputyp:=tfloatdef(right.resulttype.def).typ
  687. else
  688. if (right.nodetype=typeconvn) and
  689. (ttypeconvnode(right).left.resulttype.def.deftype=floatdef) then
  690. fputyp:=tfloatdef(ttypeconvnode(right).left.resulttype.def).typ
  691. else
  692. fputyp:=s32real;
  693. case loc of
  694. LOC_CFPUREGISTER:
  695. begin
  696. emit_reg(A_FSTP,S_NO,
  697. correct_fpuregister(left.location.register,fpuvaroffset));
  698. dec(fpuvaroffset);
  699. end;
  700. LOC_REFERENCE:
  701. floatstore(fputyp,left.location.reference);
  702. else
  703. internalerror(48991);
  704. end;
  705. end;
  706. LOC_CFPUREGISTER: begin
  707. if (left.resulttype.def.deftype=floatdef) then
  708. fputyp:=tfloatdef(left.resulttype.def).typ
  709. else
  710. if (right.resulttype.def.deftype=floatdef) then
  711. fputyp:=tfloatdef(right.resulttype.def).typ
  712. else
  713. if (right.nodetype=typeconvn) and
  714. (ttypeconvnode(right).left.resulttype.def.deftype=floatdef) then
  715. fputyp:=tfloatdef(ttypeconvnode(right).left.resulttype.def).typ
  716. else
  717. fputyp:=s32real;
  718. emit_reg(A_FLD,S_NO,
  719. correct_fpuregister(right.location.register,fpuvaroffset));
  720. inc(fpuvaroffset);
  721. case loc of
  722. LOC_CFPUREGISTER:
  723. begin
  724. emit_reg(A_FSTP,S_NO,
  725. correct_fpuregister(right.location.register,fpuvaroffset));
  726. dec(fpuvaroffset);
  727. end;
  728. LOC_REFERENCE:
  729. floatstore(fputyp,left.location.reference);
  730. else
  731. internalerror(48992);
  732. end;
  733. end;
  734. LOC_JUMP : begin
  735. opsize:=def_opsize(left.resulttype.def);
  736. getlabel(hlabel);
  737. emitlab(truelabel);
  738. if pushed then
  739. restore(left,false);
  740. if loc=LOC_CREGISTER then
  741. emit_const_reg(A_MOV,opsize,
  742. 1,left.location.register)
  743. else
  744. emit_const_ref(A_MOV,opsize,
  745. 1,newreference(left.location.reference));
  746. emitjmp(C_None,hlabel);
  747. emitlab(falselabel);
  748. if pushed then
  749. restore(left,false);
  750. if loc=LOC_CREGISTER then
  751. emit_reg_reg(A_XOR,opsize,
  752. left.location.register,
  753. left.location.register)
  754. else
  755. begin
  756. emit_const_ref(A_MOV,opsize,
  757. 0,newreference(left.location.reference));
  758. {$IfDef regallocfix}
  759. del_reference(left.location.reference);
  760. {$EndIf regallocfix}
  761. end;
  762. emitlab(hlabel);
  763. end;
  764. LOC_FLAGS : begin
  765. if loc=LOC_CREGISTER then
  766. emit_flag2reg(right.location.resflags,left.location.register)
  767. else
  768. begin
  769. ai:=Taicpu.Op_ref(A_Setcc,S_B,newreference(left.location.reference));
  770. ai.SetCondition(flag_2_cond[right.location.resflags]);
  771. exprasmList.concat(ai);
  772. end;
  773. {$IfDef regallocfix}
  774. del_reference(left.location.reference);
  775. {$EndIf regallocfix}
  776. end;
  777. end;
  778. truelabel:=otlabel;
  779. falselabel:=oflabel;
  780. end;
  781. {*****************************************************************************
  782. SecondFuncRet
  783. *****************************************************************************}
  784. procedure ti386funcretnode.pass_2;
  785. var
  786. hr : tregister;
  787. hp : preference;
  788. pp : pprocinfo;
  789. hr_valid : boolean;
  790. i : integer;
  791. begin
  792. reset_reference(location.reference);
  793. hr_valid:=false;
  794. if (not inlining_procedure) and
  795. (lexlevel<>funcretsym.owner.symtablelevel) then
  796. begin
  797. hr:=getregister32;
  798. hr_valid:=true;
  799. hp:=new_reference(procinfo^.framepointer,procinfo^.framepointer_offset);
  800. emit_ref_reg(A_MOV,S_L,hp,hr);
  801. { walk up the stack frame }
  802. pp:=procinfo^.parent;
  803. i:=lexlevel-1;
  804. while i>funcretsym.owner.symtablelevel do
  805. begin
  806. hp:=new_reference(hr,pp^.framepointer_offset);
  807. emit_ref_reg(A_MOV,S_L,hp,hr);
  808. pp:=pp^.parent;
  809. dec(i);
  810. end;
  811. location.reference.base:=hr;
  812. location.reference.offset:=pp^.return_offset;
  813. end
  814. else
  815. begin
  816. location.reference.base:=procinfo^.framepointer;
  817. location.reference.offset:=procinfo^.return_offset;
  818. end;
  819. if ret_in_param(resulttype.def) then
  820. begin
  821. if not hr_valid then
  822. hr:=getregister32;
  823. emit_ref_reg(A_MOV,S_L,newreference(location.reference),hr);
  824. location.reference.base:=hr;
  825. location.reference.offset:=0;
  826. end;
  827. end;
  828. {*****************************************************************************
  829. SecondArrayConstruct
  830. *****************************************************************************}
  831. const
  832. vtInteger = 0;
  833. vtBoolean = 1;
  834. vtChar = 2;
  835. vtExtended = 3;
  836. vtString = 4;
  837. vtPointer = 5;
  838. vtPChar = 6;
  839. vtObject = 7;
  840. vtClass = 8;
  841. vtWideChar = 9;
  842. vtPWideChar = 10;
  843. vtAnsiString = 11;
  844. vtCurrency = 12;
  845. vtVariant = 13;
  846. vtInterface = 14;
  847. vtWideString = 15;
  848. vtInt64 = 16;
  849. vtQWord = 17;
  850. procedure ti386arrayconstructornode.pass_2;
  851. var
  852. hp : tarrayconstructornode;
  853. href : treference;
  854. lt : tdef;
  855. vaddr : boolean;
  856. vtype : longint;
  857. freetemp,
  858. dovariant : boolean;
  859. elesize : longint;
  860. begin
  861. dovariant:=(nf_forcevaria in flags) or tarraydef(resulttype.def).isvariant;
  862. if dovariant then
  863. elesize:=8
  864. else
  865. elesize:=tarraydef(resulttype.def).elesize;
  866. if not(nf_cargs in flags) then
  867. begin
  868. reset_reference(location.reference);
  869. { Allocate always a temp, also if no elements are required, to
  870. be sure that location is valid (PFV) }
  871. if tarraydef(resulttype.def).highrange=-1 then
  872. gettempofsizereference(elesize,location.reference)
  873. else
  874. gettempofsizereference((tarraydef(resulttype.def).highrange+1)*elesize,location.reference);
  875. href:=location.reference;
  876. end;
  877. hp:=self;
  878. while assigned(hp) do
  879. begin
  880. if assigned(hp.left) then
  881. begin
  882. freetemp:=true;
  883. secondpass(hp.left);
  884. if codegenerror then
  885. exit;
  886. if dovariant then
  887. begin
  888. { find the correct vtype value }
  889. vtype:=$ff;
  890. vaddr:=false;
  891. lt:=hp.left.resulttype.def;
  892. case lt.deftype of
  893. enumdef,
  894. orddef :
  895. begin
  896. if is_64bitint(lt) then
  897. begin
  898. case torddef(lt).typ of
  899. s64bit:
  900. vtype:=vtInt64;
  901. u64bit:
  902. vtype:=vtQWord;
  903. end;
  904. freetemp:=false;
  905. vaddr:=true;
  906. end
  907. else if (lt.deftype=enumdef) or
  908. is_integer(lt) then
  909. vtype:=vtInteger
  910. else
  911. if is_boolean(lt) then
  912. vtype:=vtBoolean
  913. else
  914. if (lt.deftype=orddef) and (torddef(lt).typ=uchar) then
  915. vtype:=vtChar;
  916. end;
  917. floatdef :
  918. begin
  919. vtype:=vtExtended;
  920. vaddr:=true;
  921. freetemp:=false;
  922. end;
  923. procvardef,
  924. pointerdef :
  925. begin
  926. if is_pchar(lt) then
  927. vtype:=vtPChar
  928. else
  929. vtype:=vtPointer;
  930. end;
  931. classrefdef :
  932. vtype:=vtClass;
  933. objectdef :
  934. begin
  935. vtype:=vtObject;
  936. end;
  937. stringdef :
  938. begin
  939. if is_shortstring(lt) then
  940. begin
  941. vtype:=vtString;
  942. vaddr:=true;
  943. freetemp:=false;
  944. end
  945. else
  946. if is_ansistring(lt) then
  947. begin
  948. vtype:=vtAnsiString;
  949. freetemp:=false;
  950. end;
  951. end;
  952. end;
  953. if vtype=$ff then
  954. internalerror(14357);
  955. { write C style pushes or an pascal array }
  956. if nf_cargs in flags then
  957. begin
  958. if vaddr then
  959. begin
  960. emit_to_mem(hp.left.location,hp.left.resulttype.def);
  961. emit_push_lea_loc(hp.left.location,freetemp);
  962. del_reference(hp.left.location.reference);
  963. end
  964. else
  965. emit_push_loc(hp.left.location);
  966. inc(pushedparasize,4);
  967. end
  968. else
  969. begin
  970. { write changing field update href to the next element }
  971. inc(href.offset,4);
  972. if vaddr then
  973. begin
  974. emit_to_mem(hp.left.location,hp.left.resulttype.def);
  975. emit_lea_loc_ref(hp.left.location,href,freetemp);
  976. end
  977. else
  978. begin
  979. emit_mov_loc_ref(hp.left.location,href,S_L,freetemp);
  980. end;
  981. { update href to the vtype field and write it }
  982. dec(href.offset,4);
  983. emit_const_ref(A_MOV,S_L,vtype,newreference(href));
  984. { goto next array element }
  985. inc(href.offset,8);
  986. end;
  987. end
  988. else
  989. { normal array constructor of the same type }
  990. begin
  991. case elesize of
  992. 1 :
  993. emit_mov_loc_ref(hp.left.location,href,S_B,freetemp);
  994. 2 :
  995. emit_mov_loc_ref(hp.left.location,href,S_W,freetemp);
  996. 4 :
  997. emit_mov_loc_ref(hp.left.location,href,S_L,freetemp);
  998. 8 :
  999. begin
  1000. if hp.left.location.loc in [LOC_REGISTER,LOC_CREGISTER] then
  1001. begin
  1002. emit_reg_ref(A_MOV,S_L,hp.left.location.registerlow,newreference(href));
  1003. { update href to the high bytes and write it }
  1004. inc(href.offset,4);
  1005. emit_reg_ref(A_MOV,S_L,hp.left.location.registerhigh,newreference(href));
  1006. dec(href.offset,4)
  1007. end
  1008. else
  1009. concatcopy(hp.left.location.reference,href,elesize,freetemp,false);
  1010. end;
  1011. else
  1012. begin
  1013. { concatcopy only supports reference }
  1014. if not(hp.left.location.loc in [LOC_MEM,LOC_REFERENCE]) then
  1015. internalerror(200108012);
  1016. concatcopy(hp.left.location.reference,href,elesize,freetemp,false);
  1017. end;
  1018. end;
  1019. inc(href.offset,elesize);
  1020. end;
  1021. end;
  1022. { load next entry }
  1023. hp:=tarrayconstructornode(hp.right);
  1024. end;
  1025. end;
  1026. begin
  1027. cloadnode:=ti386loadnode;
  1028. cassignmentnode:=ti386assignmentnode;
  1029. cfuncretnode:=ti386funcretnode;
  1030. carrayconstructornode:=ti386arrayconstructornode;
  1031. end.
  1032. {
  1033. $Log$
  1034. Revision 1.22 2001-09-09 08:51:09 jonas
  1035. * fixed bug with assigning ansistrings (left^.location was released too
  1036. early, caused bug reported by Aleksey V. Vaneev in mailing list on
  1037. 2001/09/07 regarding 'problems with nested procedures and local vars'
  1038. ("merged" from cga.pas in the fixes branch)
  1039. Revision 1.21 2001/08/30 20:13:57 peter
  1040. * rtti/init table updates
  1041. * rttisym for reusable global rtti/init info
  1042. * support published for interfaces
  1043. Revision 1.20 2001/08/30 11:57:20 michael
  1044. + Patch for wrong paramsize
  1045. Revision 1.19 2001/08/26 13:36:59 florian
  1046. * some cg reorganisation
  1047. * some PPC updates
  1048. Revision 1.18 2001/08/06 21:40:50 peter
  1049. * funcret moved from tprocinfo to tprocdef
  1050. Revision 1.17 2001/08/05 13:19:51 peter
  1051. * partly fix for proc of obj=nil
  1052. Revision 1.15 2001/07/28 15:13:17 peter
  1053. * fixed opsize for assignment with LOC_JUMP
  1054. Revision 1.14 2001/05/27 14:30:56 florian
  1055. + some widestring stuff added
  1056. Revision 1.13 2001/04/13 01:22:19 peter
  1057. * symtable change to classes
  1058. * range check generation and errors fixed, make cycle DEBUG=1 works
  1059. * memory leaks fixed
  1060. Revision 1.12 2001/04/02 21:20:37 peter
  1061. * resulttype rewrite
  1062. Revision 1.11 2000/12/25 00:07:33 peter
  1063. + new tlinkedlist class (merge of old tstringqueue,tcontainer and
  1064. tlinkedlist objects)
  1065. Revision 1.10 2000/12/05 11:44:33 jonas
  1066. + new integer regvar handling, should be much more efficient
  1067. Revision 1.9 2000/11/29 00:30:48 florian
  1068. * unused units removed from uses clause
  1069. * some changes for widestrings
  1070. Revision 1.8 2000/11/13 14:44:36 jonas
  1071. * fixes so no more range errors with improved range checking code
  1072. Revision 1.7 2000/11/12 23:24:15 florian
  1073. * interfaces are basically running
  1074. Revision 1.6 2000/11/11 22:59:20 florian
  1075. * fixed resourcestrings, made a stupid mistake yesterday
  1076. Revision 1.5 2000/11/09 18:52:06 florian
  1077. * resourcestrings doesn't need the helper anymore they
  1078. access the table now direct
  1079. Revision 1.4 2000/11/06 23:15:02 peter
  1080. * added copyvaluepara call again
  1081. Revision 1.3 2000/11/04 14:25:23 florian
  1082. + merged Attila's changes for interfaces, not tested yet
  1083. Revision 1.2 2000/10/31 22:02:56 peter
  1084. * symtable splitted, no real code changes
  1085. Revision 1.1 2000/10/15 09:33:31 peter
  1086. * moved n386*.pas to i386/ cpu_target dir
  1087. Revision 1.1 2000/10/14 10:14:49 peter
  1088. * moehrendorf oct 2000 rewrite
  1089. }