cg386mat.pas 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850
  1. {
  2. $Id$
  3. Copyright (c) 1993-98 by Florian Klaempfl
  4. Generate i386 assembler for math 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 cg386mat;
  19. interface
  20. uses
  21. tree;
  22. procedure secondmoddiv(var p : ptree);
  23. procedure secondshlshr(var p : ptree);
  24. procedure secondumminus(var p : ptree);
  25. procedure secondnot(var p : ptree);
  26. implementation
  27. uses
  28. globtype,systems,
  29. cobjects,verbose,globals,
  30. symtable,aasm,types,
  31. hcodegen,temp_gen,pass_2,
  32. {$ifdef ag386bin}
  33. i386base,i386asm,
  34. {$else}
  35. i386,
  36. {$endif}
  37. cgai386,tgeni386;
  38. {*****************************************************************************
  39. SecondModDiv
  40. *****************************************************************************}
  41. procedure secondmoddiv(var p : ptree);
  42. var
  43. hreg1 : tregister;
  44. pushed,popeax,popedx : boolean;
  45. power : longint;
  46. hl : plabel;
  47. begin
  48. secondpass(p^.left);
  49. set_location(p^.location,p^.left^.location);
  50. pushed:=maybe_push(p^.right^.registers32,p);
  51. secondpass(p^.right);
  52. if pushed then restore(p);
  53. { put numerator in register }
  54. if p^.left^.location.loc<>LOC_REGISTER then
  55. begin
  56. if p^.left^.location.loc=LOC_CREGISTER then
  57. begin
  58. hreg1:=getregister32;
  59. emit_reg_reg(A_MOV,S_L,p^.left^.location.register,hreg1);
  60. end
  61. else
  62. begin
  63. del_reference(p^.left^.location.reference);
  64. hreg1:=getregister32;
  65. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
  66. hreg1)));
  67. end;
  68. clear_location(p^.left^.location);
  69. p^.left^.location.loc:=LOC_REGISTER;
  70. p^.left^.location.register:=hreg1;
  71. end
  72. else hreg1:=p^.left^.location.register;
  73. if (p^.treetype=divn) and (p^.right^.treetype=ordconstn) and
  74. ispowerof2(p^.right^.value,power) then
  75. begin
  76. exprasmlist^.concat(new(pai386,op_reg_reg(A_OR,S_L,hreg1,hreg1)));
  77. getlabel(hl);
  78. emitjmp(C_NS,hl);
  79. if power=1 then
  80. exprasmlist^.concat(new(pai386,op_reg(A_INC,S_L,hreg1)))
  81. else
  82. exprasmlist^.concat(new(pai386,op_const_reg(A_ADD,S_L,p^.right^.value-1,hreg1)));
  83. emitlab(hl);
  84. exprasmlist^.concat(new(pai386,op_const_reg(A_SAR,S_L,power,hreg1)));
  85. end
  86. else
  87. begin
  88. { bring denominator to EDI }
  89. { EDI is always free, it's }
  90. { only used for temporary }
  91. { purposes }
  92. if (p^.right^.location.loc<>LOC_REGISTER) and
  93. (p^.right^.location.loc<>LOC_CREGISTER) then
  94. begin
  95. del_reference(p^.right^.location.reference);
  96. p^.left^.location.loc:=LOC_REGISTER;
  97. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.right^.location.reference),R_EDI)));
  98. end
  99. else
  100. begin
  101. ungetregister32(p^.right^.location.register);
  102. emit_reg_reg(A_MOV,S_L,p^.right^.location.register,R_EDI);
  103. end;
  104. popedx:=false;
  105. popeax:=false;
  106. if hreg1=R_EDX then
  107. begin
  108. if not(R_EAX in unused) then
  109. begin
  110. exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EAX)));
  111. popeax:=true;
  112. end;
  113. emit_reg_reg(A_MOV,S_L,R_EDX,R_EAX);
  114. end
  115. else
  116. begin
  117. if not(R_EDX in unused) then
  118. begin
  119. exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EDX)));
  120. popedx:=true;
  121. end;
  122. if hreg1<>R_EAX then
  123. begin
  124. if not(R_EAX in unused) then
  125. begin
  126. exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EAX)));
  127. popeax:=true;
  128. end;
  129. emit_reg_reg(A_MOV,S_L,hreg1,R_EAX);
  130. end;
  131. end;
  132. { sign extension depends on the left type }
  133. if porddef(p^.left^.resulttype)^.typ=u32bit then
  134. exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,R_EDX,R_EDX)))
  135. else
  136. exprasmlist^.concat(new(pai386,op_none(A_CDQ,S_NO)));
  137. { division depends on the right type }
  138. if porddef(p^.right^.resulttype)^.typ=u32bit then
  139. exprasmlist^.concat(new(pai386,op_reg(A_DIV,S_L,R_EDI)))
  140. else
  141. exprasmlist^.concat(new(pai386,op_reg(A_IDIV,S_L,R_EDI)));
  142. if p^.treetype=divn then
  143. begin
  144. { if result register is busy then copy }
  145. if popeax then
  146. begin
  147. if hreg1=R_EAX then
  148. internalerror(112);
  149. emit_reg_reg(A_MOV,S_L,R_EAX,hreg1)
  150. end
  151. else
  152. if hreg1<>R_EAX then
  153. emit_reg_reg(A_MOV,S_L,R_EAX,hreg1);
  154. end
  155. else
  156. emit_reg_reg(A_MOV,S_L,R_EDX,hreg1);
  157. if popeax then
  158. exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EAX)));
  159. if popedx then
  160. exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EDX)));
  161. end;
  162. { this registers are always used when div/mod are present }
  163. usedinproc:=usedinproc or ($80 shr byte(R_EAX));
  164. usedinproc:=usedinproc or ($80 shr byte(R_EDX));
  165. clear_location(p^.location);
  166. p^.location.loc:=LOC_REGISTER;
  167. p^.location.register:=hreg1;
  168. end;
  169. {*****************************************************************************
  170. SecondShlShr
  171. *****************************************************************************}
  172. procedure secondshlshr(var p : ptree);
  173. var
  174. hregister1,hregister2,hregister3,
  175. hregisterhigh,hregisterlow : tregister;
  176. pushed,popecx : boolean;
  177. op : tasmop;
  178. hr : preference;
  179. begin
  180. popecx:=false;
  181. secondpass(p^.left);
  182. pushed:=maybe_push(p^.right^.registers32,p);
  183. secondpass(p^.right);
  184. if pushed then
  185. restore(p);
  186. if is_64bitint(p^.left^.resulttype) then
  187. begin
  188. { load left operators in a register }
  189. if p^.left^.location.loc<>LOC_REGISTER then
  190. begin
  191. if p^.left^.location.loc=LOC_CREGISTER then
  192. begin
  193. hregisterlow:=getregister32;
  194. hregisterhigh:=getregister32;
  195. emit_reg_reg(A_MOV,S_L,p^.left^.location.registerlow,
  196. hregisterlow);
  197. emit_reg_reg(A_MOV,S_L,p^.left^.location.registerhigh,
  198. hregisterlow);
  199. end
  200. else
  201. begin
  202. del_reference(p^.left^.location.reference);
  203. hregisterlow:=getregister32;
  204. hregisterhigh:=getregister32;
  205. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
  206. hregisterlow)));
  207. hr:=newreference(p^.left^.location.reference);
  208. inc(hr^.offset,4);
  209. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,hr,
  210. hregisterhigh)));
  211. end;
  212. end
  213. else
  214. begin
  215. hregisterlow:=p^.left^.location.registerlow;
  216. hregisterhigh:=p^.left^.location.registerhigh;
  217. end;
  218. { shifting by a constant directly coded: }
  219. if (p^.right^.treetype=ordconstn) then
  220. begin
  221. if p^.treetype=shln then
  222. begin
  223. exprasmlist^.concat(new(pai386,op_const_reg_reg(A_SHLD,S_L,p^.right^.location.reference.offset and 31,
  224. hregisterlow,hregisterhigh)));
  225. exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,p^.right^.location.reference.offset and 31,
  226. hregisterlow)));
  227. end
  228. else
  229. begin
  230. exprasmlist^.concat(new(pai386,op_const_reg_reg(A_SHRD,S_L,p^.right^.location.reference.offset and 31,
  231. hregisterhigh,hregisterlow)));
  232. exprasmlist^.concat(new(pai386,op_const_reg(A_SHR,S_L,p^.right^.location.reference.offset and 31,
  233. hregisterhigh)));
  234. end;
  235. p^.location.loc:=LOC_REGISTER;
  236. p^.location.registerlow:=hregisterlow;
  237. p^.location.registerhigh:=hregisterhigh;
  238. end
  239. else
  240. begin
  241. { load right operators in a register }
  242. if p^.right^.location.loc<>LOC_REGISTER then
  243. begin
  244. if p^.right^.location.loc=LOC_CREGISTER then
  245. begin
  246. hregister2:=getexplicitregister32(R_ECX);
  247. emit_reg_reg(A_MOV,S_L,p^.right^.location.register,
  248. hregister2);
  249. end
  250. else
  251. begin
  252. del_reference(p^.right^.location.reference);
  253. hregister2:=getexplicitregister32(R_ECX);
  254. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.right^.location.reference),
  255. hregister2)));
  256. end;
  257. end
  258. else
  259. hregister2:=p^.right^.location.register;
  260. { left operator is already in a register }
  261. { hence are both in a register }
  262. { is it in the case ECX ? }
  263. if (hregisterlow=R_ECX) then
  264. begin
  265. { then only swap }
  266. emit_reg_reg(A_XCHG,S_L,hregisterlow,hregister2);
  267. hregister3:=hregisterlow;
  268. hregisterlow:=hregister2;
  269. hregister2:=hregister3;
  270. end
  271. else if (hregisterhigh=R_ECX) then
  272. begin
  273. { then only swap }
  274. emit_reg_reg(A_XCHG,S_L,hregisterhigh,hregister2);
  275. hregister3:=hregisterhigh;
  276. hregisterhigh:=hregister2;
  277. hregister2:=hregister3;
  278. end
  279. { if second operator not in ECX ? }
  280. else if (hregister2<>R_ECX) then
  281. begin
  282. { ECX occupied then push it }
  283. if not (R_ECX in unused) then
  284. begin
  285. popecx:=true;
  286. exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ECX)));
  287. end;
  288. emit_reg_reg(A_MOV,S_L,hregister2,R_ECX);
  289. end;
  290. ungetregister32(hregister2);
  291. if p^.treetype=shln then
  292. begin
  293. exprasmlist^.concat(new(pai386,op_reg_reg_reg(A_SHLD,S_L,R_CL,
  294. hregisterlow,hregisterhigh)));
  295. exprasmlist^.concat(new(pai386,op_reg_reg(A_SHL,S_L,R_CL,
  296. hregisterlow)));
  297. end
  298. else
  299. begin
  300. exprasmlist^.concat(new(pai386,op_reg_reg_reg(A_SHRD,S_L,R_CL,
  301. hregisterhigh,hregisterlow)));
  302. exprasmlist^.concat(new(pai386,op_reg_reg(A_SHR,S_L,R_CL,
  303. hregisterhigh)));
  304. end;
  305. { maybe put ECX back }
  306. if popecx then
  307. exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_ECX)));
  308. p^.location.registerlow:=hregisterlow;
  309. p^.location.registerhigh:=hregisterhigh;
  310. end;
  311. end
  312. else
  313. begin
  314. { load left operators in a register }
  315. if p^.left^.location.loc<>LOC_REGISTER then
  316. begin
  317. if p^.left^.location.loc=LOC_CREGISTER then
  318. begin
  319. hregister1:=getregister32;
  320. emit_reg_reg(A_MOV,S_L,p^.left^.location.register,
  321. hregister1);
  322. end
  323. else
  324. begin
  325. del_reference(p^.left^.location.reference);
  326. hregister1:=getregister32;
  327. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
  328. hregister1)));
  329. end;
  330. end
  331. else
  332. hregister1:=p^.left^.location.register;
  333. { determine operator }
  334. if p^.treetype=shln then
  335. op:=A_SHL
  336. else
  337. op:=A_SHR;
  338. { shifting by a constant directly coded: }
  339. if (p^.right^.treetype=ordconstn) then
  340. begin
  341. exprasmlist^.concat(new(pai386,op_const_reg(op,S_L,p^.right^.location.reference.offset and 31,
  342. hregister1)));
  343. p^.location.loc:=LOC_REGISTER;
  344. p^.location.register:=hregister1;
  345. end
  346. else
  347. begin
  348. { load right operators in a register }
  349. if p^.right^.location.loc<>LOC_REGISTER then
  350. begin
  351. if p^.right^.location.loc=LOC_CREGISTER then
  352. begin
  353. hregister2:=getexplicitregister32(R_ECX);
  354. emit_reg_reg(A_MOV,S_L,p^.right^.location.register,
  355. hregister2);
  356. end
  357. else
  358. begin
  359. del_reference(p^.right^.location.reference);
  360. hregister2:=getexplicitregister32(R_ECX);
  361. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.right^.location.reference),
  362. hregister2)));
  363. end;
  364. end
  365. else
  366. hregister2:=p^.right^.location.register;
  367. { left operator is already in a register }
  368. { hence are both in a register }
  369. { is it in the case ECX ? }
  370. if (hregister1=R_ECX) then
  371. begin
  372. { then only swap }
  373. emit_reg_reg(A_XCHG,S_L,hregister1,hregister2);
  374. hregister3:=hregister1;
  375. hregister1:=hregister2;
  376. hregister2:=hregister3;
  377. end
  378. { if second operator not in ECX ? }
  379. else if (hregister2<>R_ECX) then
  380. begin
  381. { ECX occupied then push it }
  382. if not (R_ECX in unused) then
  383. begin
  384. popecx:=true;
  385. exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ECX)));
  386. end;
  387. emit_reg_reg(A_MOV,S_L,hregister2,R_ECX);
  388. end;
  389. ungetregister32(hregister2);
  390. { right operand is in ECX }
  391. emit_reg_reg(op,S_L,R_CL,hregister1);
  392. { maybe ECX back }
  393. if popecx then
  394. exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_ECX)));
  395. p^.location.register:=hregister1;
  396. end;
  397. end;
  398. end;
  399. {*****************************************************************************
  400. SecondUmMinus
  401. *****************************************************************************}
  402. procedure secondumminus(var p : ptree);
  403. {$ifdef SUPPORT_MMX}
  404. procedure do_mmx_neg;
  405. var
  406. op : tasmop;
  407. begin
  408. p^.location.loc:=LOC_MMXREGISTER;
  409. if cs_mmx_saturation in aktlocalswitches then
  410. case mmx_type(p^.resulttype) of
  411. mmxs8bit:
  412. op:=A_PSUBSB;
  413. mmxu8bit:
  414. op:=A_PSUBUSB;
  415. mmxs16bit,mmxfixed16:
  416. op:=A_PSUBSW;
  417. mmxu16bit:
  418. op:=A_PSUBUSW;
  419. end
  420. else
  421. case mmx_type(p^.resulttype) of
  422. mmxs8bit,mmxu8bit:
  423. op:=A_PSUBB;
  424. mmxs16bit,mmxu16bit,mmxfixed16:
  425. op:=A_PSUBW;
  426. mmxs32bit,mmxu32bit:
  427. op:=A_PSUBD;
  428. end;
  429. emit_reg_reg(op,S_NO,p^.location.register,R_MM7);
  430. emit_reg_reg(A_MOVQ,S_NO,R_MM7,p^.location.register);
  431. end;
  432. {$endif}
  433. var
  434. hr : preference;
  435. begin
  436. if is_64bitint(p^.left^.resulttype) then
  437. begin
  438. secondpass(p^.left);
  439. clear_location(p^.location);
  440. p^.location.loc:=LOC_REGISTER;
  441. case p^.left^.location.loc of
  442. LOC_REGISTER :
  443. begin
  444. p^.location.registerlow:=p^.left^.location.registerlow;
  445. p^.location.registerhigh:=p^.left^.location.registerhigh;
  446. end;
  447. LOC_CREGISTER :
  448. begin
  449. p^.location.registerlow:=getregister32;
  450. p^.location.registerhigh:=getregister32;
  451. emit_reg_reg(A_MOV,S_L,p^.left^.location.registerlow,p^.location.registerlow);
  452. emit_reg_reg(A_MOV,S_L,p^.left^.location.registerhigh,p^.location.registerhigh);
  453. end;
  454. LOC_REFERENCE,LOC_MEM :
  455. begin
  456. del_reference(p^.left^.location.reference);
  457. p^.location.registerlow:=getregister32;
  458. p^.location.registerhigh:=getregister32;
  459. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
  460. newreference(p^.left^.location.reference),p^.location.registerlow)));
  461. hr:=newreference(p^.left^.location.reference);
  462. inc(hr^.offset,4);
  463. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
  464. hr,p^.location.registerhigh)));
  465. end;
  466. end;
  467. exprasmlist^.concat(new(pai386,op_reg(A_NEG,S_L,p^.location.registerlow)));
  468. exprasmlist^.concat(new(pai386,op_const_reg(A_ADC,S_L,0,p^.location.registerhigh)));
  469. exprasmlist^.concat(new(pai386,op_reg(A_NEG,S_L,p^.location.registerhigh)));
  470. end
  471. else
  472. begin
  473. secondpass(p^.left);
  474. p^.location.loc:=LOC_REGISTER;
  475. case p^.left^.location.loc of
  476. LOC_REGISTER:
  477. begin
  478. p^.location.register:=p^.left^.location.register;
  479. exprasmlist^.concat(new(pai386,op_reg(A_NEG,S_L,p^.location.register)));
  480. end;
  481. LOC_CREGISTER:
  482. begin
  483. p^.location.register:=getregister32;
  484. emit_reg_reg(A_MOV,S_L,p^.location.register,
  485. p^.location.register);
  486. exprasmlist^.concat(new(pai386,op_reg(A_NEG,S_L,p^.location.register)));
  487. end;
  488. {$ifdef SUPPORT_MMX}
  489. LOC_MMXREGISTER:
  490. begin
  491. set_location(p^.location,p^.left^.location);
  492. emit_reg_reg(A_PXOR,S_NO,R_MM7,R_MM7);
  493. do_mmx_neg;
  494. end;
  495. LOC_CMMXREGISTER:
  496. begin
  497. p^.location.register:=getregistermmx;
  498. emit_reg_reg(A_PXOR,S_NO,R_MM7,R_MM7);
  499. emit_reg_reg(A_MOVQ,S_NO,p^.left^.location.register,
  500. p^.location.register);
  501. do_mmx_neg;
  502. end;
  503. {$endif SUPPORT_MMX}
  504. LOC_REFERENCE,LOC_MEM:
  505. begin
  506. del_reference(p^.left^.location.reference);
  507. if (p^.left^.resulttype^.deftype=floatdef) and
  508. (pfloatdef(p^.left^.resulttype)^.typ<>f32bit) then
  509. begin
  510. p^.location.loc:=LOC_FPU;
  511. floatload(pfloatdef(p^.left^.resulttype)^.typ,
  512. p^.left^.location.reference);
  513. exprasmlist^.concat(new(pai386,op_none(A_FCHS,S_NO)));
  514. end
  515. {$ifdef SUPPORT_MMX}
  516. else if (cs_mmx in aktlocalswitches) and is_mmx_able_array(p^.left^.resulttype) then
  517. begin
  518. p^.location.register:=getregistermmx;
  519. emit_reg_reg(A_PXOR,S_NO,R_MM7,R_MM7);
  520. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVQ,S_NO,
  521. newreference(p^.left^.location.reference),
  522. p^.location.register)));
  523. do_mmx_neg;
  524. end
  525. {$endif SUPPORT_MMX}
  526. else
  527. begin
  528. p^.location.register:=getregister32;
  529. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
  530. newreference(p^.left^.location.reference),
  531. p^.location.register)));
  532. exprasmlist^.concat(new(pai386,op_reg(A_NEG,S_L,p^.location.register)));
  533. end;
  534. end;
  535. LOC_FPU:
  536. begin
  537. p^.location.loc:=LOC_FPU;
  538. exprasmlist^.concat(new(pai386,op_none(A_FCHS,S_NO)));
  539. end;
  540. end;
  541. end;
  542. { Here was a problem... }
  543. { Operand to be negated always }
  544. { seems to be converted to signed }
  545. { 32-bit before doing neg!! }
  546. { So this is useless... }
  547. { emitoverflowcheck(p);}
  548. end;
  549. {*****************************************************************************
  550. SecondNot
  551. *****************************************************************************}
  552. procedure secondnot(var p : ptree);
  553. const
  554. flagsinvers : array[F_E..F_BE] of tresflags =
  555. (F_NE,F_E,F_LE,F_GE,F_L,F_G,F_NC,F_C,
  556. F_A,F_AE,F_B,F_BE);
  557. var
  558. hl : plabel;
  559. opsize : topsize;
  560. hr : preference;
  561. begin
  562. if is_boolean(p^.resulttype) then
  563. begin
  564. opsize:=def_opsize(p^.resulttype);
  565. case p^.left^.location.loc of
  566. LOC_JUMP :
  567. begin
  568. hl:=truelabel;
  569. truelabel:=falselabel;
  570. falselabel:=hl;
  571. secondpass(p^.left);
  572. maketojumpbool(p^.left);
  573. hl:=truelabel;
  574. truelabel:=falselabel;
  575. falselabel:=hl;
  576. end;
  577. LOC_FLAGS :
  578. begin
  579. secondpass(p^.left);
  580. p^.location.resflags:=flagsinvers[p^.left^.location.resflags];
  581. end;
  582. LOC_REGISTER :
  583. begin
  584. secondpass(p^.left);
  585. {p^.location.register:=p^.left^.location.register;
  586. exprasmlist^.concat(new(pai386,op_const_reg(A_XOR,opsize,1,p^.location.register)));}
  587. p^.location.loc:=LOC_FLAGS;
  588. p^.location.resflags:=F_E;
  589. exprasmlist^.concat(new(pai386,op_reg_reg(A_TEST,opsize,
  590. p^.left^.location.register,p^.left^.location.register)));
  591. ungetregister(p^.left^.location.register);
  592. end;
  593. LOC_CREGISTER :
  594. begin
  595. secondpass(p^.left);
  596. clear_location(p^.location);
  597. p^.location.loc:=LOC_REGISTER;
  598. p^.location.register:=def_getreg(p^.resulttype);
  599. emit_reg_reg(A_MOV,opsize,p^.left^.location.register,p^.location.register);
  600. exprasmlist^.concat(new(pai386,op_reg_reg(A_TEST,opsize,p^.location.register,p^.location.register)));
  601. ungetregister(p^.location.register);
  602. p^.location.loc:=LOC_FLAGS;
  603. p^.location.resflags:=F_E;
  604. end;
  605. LOC_REFERENCE,
  606. LOC_MEM :
  607. begin
  608. secondpass(p^.left);
  609. clear_location(p^.location);
  610. p^.location.loc:=LOC_REGISTER;
  611. del_reference(p^.left^.location.reference);
  612. { this was placed before del_ref => internaalerror(10) }
  613. p^.location.register:=def_getreg(p^.resulttype);
  614. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
  615. newreference(p^.left^.location.reference),p^.location.register)));
  616. exprasmlist^.concat(new(pai386,op_reg_reg(A_TEST,opsize,p^.location.register,p^.location.register)));
  617. ungetregister(p^.location.register);
  618. p^.location.loc:=LOC_FLAGS;
  619. p^.location.resflags:=F_E;
  620. end;
  621. end;
  622. end
  623. {$ifdef SUPPORT_MMX}
  624. else
  625. if (cs_mmx in aktlocalswitches) and is_mmx_able_array(p^.left^.resulttype) then
  626. begin
  627. secondpass(p^.left);
  628. p^.location.loc:=LOC_MMXREGISTER;
  629. { prepare EDI }
  630. exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,S_L,$ffffffff,R_EDI)));
  631. { load operand }
  632. case p^.left^.location.loc of
  633. LOC_MMXREGISTER:
  634. set_location(p^.location,p^.left^.location);
  635. LOC_CMMXREGISTER:
  636. begin
  637. p^.location.register:=getregistermmx;
  638. emit_reg_reg(A_MOVQ,S_NO,p^.left^.location.register,p^.location.register);
  639. end;
  640. LOC_REFERENCE,LOC_MEM:
  641. begin
  642. del_reference(p^.left^.location.reference);
  643. p^.location.register:=getregistermmx;
  644. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVQ,S_NO,
  645. newreference(p^.left^.location.reference),p^.location.register)));
  646. end;
  647. end;
  648. { load mask }
  649. emit_reg_reg(A_MOV,S_D,R_EDI,R_MM7);
  650. { lower 32 bit }
  651. emit_reg_reg(A_PXOR,S_D,R_MM7,p^.location.register);
  652. { shift mask }
  653. exprasmlist^.concat(new(pai386,op_const_reg(A_PSLLQ,S_NO,32,R_MM7)));
  654. { higher 32 bit }
  655. emit_reg_reg(A_PXOR,S_D,R_MM7,p^.location.register);
  656. end
  657. {$endif SUPPORT_MMX}
  658. else if is_64bitint(p^.left^.resulttype) then
  659. begin
  660. secondpass(p^.left);
  661. clear_location(p^.location);
  662. p^.location.loc:=LOC_REGISTER;
  663. case p^.left^.location.loc of
  664. LOC_REGISTER :
  665. begin
  666. p^.location.registerlow:=p^.left^.location.registerlow;
  667. p^.location.registerhigh:=p^.left^.location.registerhigh;
  668. exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerlow)));
  669. exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerhigh)));
  670. end;
  671. LOC_CREGISTER :
  672. begin
  673. p^.location.registerlow:=getregister32;
  674. p^.location.registerhigh:=getregister32;
  675. emit_reg_reg(A_MOV,S_L,p^.left^.location.registerlow,p^.location.registerlow);
  676. emit_reg_reg(A_MOV,S_L,p^.left^.location.registerhigh,p^.location.registerhigh);
  677. exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerlow)));
  678. exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerhigh)));
  679. end;
  680. LOC_REFERENCE,LOC_MEM :
  681. begin
  682. del_reference(p^.left^.location.reference);
  683. p^.location.registerlow:=getregister32;
  684. p^.location.registerhigh:=getregister32;
  685. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
  686. newreference(p^.left^.location.reference),p^.location.registerlow)));
  687. hr:=newreference(p^.left^.location.reference);
  688. inc(hr^.offset,4);
  689. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
  690. hr,p^.location.registerhigh)));
  691. exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerlow)));
  692. exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerhigh)));
  693. end;
  694. end;
  695. end
  696. else
  697. begin
  698. secondpass(p^.left);
  699. clear_location(p^.location);
  700. p^.location.loc:=LOC_REGISTER;
  701. case p^.left^.location.loc of
  702. LOC_REGISTER :
  703. begin
  704. p^.location.register:=p^.left^.location.register;
  705. exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.register)));
  706. end;
  707. LOC_CREGISTER :
  708. begin
  709. p^.location.register:=getregister32;
  710. emit_reg_reg(A_MOV,S_L,p^.left^.location.register,p^.location.register);
  711. exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.register)));
  712. end;
  713. LOC_REFERENCE,LOC_MEM :
  714. begin
  715. del_reference(p^.left^.location.reference);
  716. p^.location.register:=getregister32;
  717. exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
  718. newreference(p^.left^.location.reference),p^.location.register)));
  719. exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.register)));
  720. end;
  721. end;
  722. end;
  723. end;
  724. end.
  725. {
  726. $Log$
  727. Revision 1.20 1999-02-22 02:15:13 peter
  728. * updates for ag386bin
  729. Revision 1.19 1999/02/04 10:49:40 florian
  730. + range checking for ansi- and widestrings
  731. * made it compilable with TP
  732. Revision 1.18 1999/02/03 10:11:12 pierre
  733. * fix for bug0211 for i386
  734. Revision 1.17 1999/01/21 22:10:41 peter
  735. * fixed array of const
  736. * generic platform independent high() support
  737. Revision 1.16 1999/01/19 10:51:32 pierre
  738. * fix to bug0183 in secondnot
  739. Revision 1.15 1998/12/11 16:50:22 florian
  740. + typed const int64 and qword
  741. + unary minus-operator q1:=-q2;
  742. + not-operator
  743. Revision 1.14 1998/12/11 16:10:07 florian
  744. + shifting for 64 bit ints added
  745. * bug in getexplicitregister32 fixed: usableregs wasn't decremented !!
  746. Revision 1.13 1998/12/11 00:02:52 peter
  747. + globtype,tokens,version unit splitted from globals
  748. Revision 1.12 1998/11/26 21:45:29 jonas
  749. - removed A_CLTD opcode (use A_CDQ instead)
  750. * changed cbw, cwde and cwd to cbtw, cwtl and cwtd in att_op2str array
  751. * in daopt386: adapted AsmInstr array to reflect changes + fixed line too long
  752. Revision 1.11 1998/11/05 14:26:02 peter
  753. * fixed shlshr which would push ecx when not needed
  754. Revision 1.10 1998/10/20 13:12:38 peter
  755. * fixed 'not not boolean', the location was not set to register
  756. Revision 1.9 1998/10/20 08:06:42 pierre
  757. * several memory corruptions due to double freemem solved
  758. => never use p^.loc.location:=p^.left^.loc.location;
  759. + finally I added now by default
  760. that ra386dir translates global and unit symbols
  761. + added a first field in tsymtable and
  762. a nextsym field in tsym
  763. (this allows to obtain ordered type info for
  764. records and objects in gdb !)
  765. Revision 1.8 1998/10/09 08:56:24 pierre
  766. * several memory leaks fixed
  767. Revision 1.7 1998/09/17 09:42:17 peter
  768. + pass_2 for cg386
  769. * Message() -> CGMessage() for pass_1/pass_2
  770. Revision 1.6 1998/09/09 14:37:37 florian
  771. * mod/div for cardinal type fixed
  772. Revision 1.5 1998/08/23 16:07:20 florian
  773. * internalerror with mod/div fixed
  774. Revision 1.4 1998/08/18 09:24:38 pierre
  775. * small warning position bug fixed
  776. * support_mmx switches splitting was missing
  777. * rhide error and warning output corrected
  778. Revision 1.3 1998/06/05 17:44:12 peter
  779. * splitted cgi386
  780. Revision 1.2 1998/06/02 17:02:59 pierre
  781. * with node corrected for objects
  782. * small bugs for SUPPORT_MMX fixed
  783. Revision 1.1 1998/06/01 16:50:18 peter
  784. + boolean -> ord conversion
  785. * fixed ord -> boolean conversion
  786. }