cgbase.pas 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690
  1. {
  2. Copyright (c) 1998-2002 by Florian Klaempfl
  3. Some basic types and constants for the code generation
  4. This program is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation; either version 2 of the License, or
  7. (at your option) any later version.
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. GNU General Public License for more details.
  12. You should have received a copy of the GNU General Public License
  13. along with this program; if not, write to the Free Software
  14. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  15. ****************************************************************************
  16. }
  17. {# This unit exports some types which are used across the code generator }
  18. unit cgbase;
  19. {$i fpcdefs.inc}
  20. interface
  21. uses
  22. globtype,
  23. symconst;
  24. type
  25. { Location types where value can be stored }
  26. TCGLoc=(
  27. LOC_INVALID, { added for tracking problems}
  28. LOC_VOID, { no value is available }
  29. LOC_CONSTANT, { constant value }
  30. LOC_JUMP, { boolean results only, jump to false or true label }
  31. LOC_FLAGS, { boolean results only, flags are set }
  32. LOC_CREFERENCE, { in memory constant value reference (cannot change) }
  33. LOC_REFERENCE, { in memory value }
  34. LOC_REGISTER, { in a processor register }
  35. LOC_CREGISTER, { Constant register which shouldn't be modified }
  36. LOC_FPUREGISTER, { FPU stack }
  37. LOC_CFPUREGISTER, { if it is a FPU register variable on the fpu stack }
  38. LOC_MMXREGISTER, { MMX register }
  39. { MMX register variable }
  40. LOC_CMMXREGISTER,
  41. { multimedia register }
  42. LOC_MMREGISTER,
  43. { Constant multimedia reg which shouldn't be modified }
  44. LOC_CMMREGISTER,
  45. { contiguous subset of bits of an integer register }
  46. LOC_SUBSETREG,
  47. LOC_CSUBSETREG,
  48. { contiguous subset of bits in memory }
  49. LOC_SUBSETREF,
  50. LOC_CSUBSETREF
  51. );
  52. { since we have only 16bit offsets, we need to be able to specify the high
  53. and lower 16 bits of the address of a symbol of up to 64 bit }
  54. trefaddr = (
  55. addr_no,
  56. addr_full,
  57. addr_pic
  58. {$IF defined(POWERPC) or defined(POWERPC64) or defined(SPARC)}
  59. ,
  60. addr_low, // bits 48-63
  61. addr_high, // bits 32-47
  62. {$IF defined(POWERPC64)}
  63. addr_higher, // bits 16-31
  64. addr_highest, // bits 00-15
  65. {$ENDIF}
  66. addr_higha // bits 16-31, adjusted
  67. {$IF defined(POWERPC64)}
  68. ,
  69. addr_highera, // bits 32-47, adjusted
  70. addr_highesta // bits 48-63, adjusted
  71. {$ENDIF}
  72. {$ENDIF}
  73. );
  74. {# Generic opcodes, which must be supported by all processors
  75. }
  76. topcg =
  77. (
  78. OP_NONE,
  79. OP_MOVE, { replaced operation with direct load }
  80. OP_ADD, { simple addition }
  81. OP_AND, { simple logical and }
  82. OP_DIV, { simple unsigned division }
  83. OP_IDIV, { simple signed division }
  84. OP_IMUL, { simple signed multiply }
  85. OP_MUL, { simple unsigned multiply }
  86. OP_NEG, { simple negate }
  87. OP_NOT, { simple logical not }
  88. OP_OR, { simple logical or }
  89. OP_SAR, { arithmetic shift-right }
  90. OP_SHL, { logical shift left }
  91. OP_SHR, { logical shift right }
  92. OP_SUB, { simple subtraction }
  93. OP_XOR, { simple exclusive or }
  94. OP_ROL, { rotate left }
  95. OP_ROR { rotate right }
  96. );
  97. {# Generic flag values - used for jump locations }
  98. TOpCmp =
  99. (
  100. OC_NONE,
  101. OC_EQ, { equality comparison }
  102. OC_GT, { greater than (signed) }
  103. OC_LT, { less than (signed) }
  104. OC_GTE, { greater or equal than (signed) }
  105. OC_LTE, { less or equal than (signed) }
  106. OC_NE, { not equal }
  107. OC_BE, { less or equal than (unsigned) }
  108. OC_B, { less than (unsigned) }
  109. OC_AE, { greater or equal than (unsigned) }
  110. OC_A { greater than (unsigned) }
  111. );
  112. { OS_NO is also used memory references with large data that can
  113. not be loaded in a register directly }
  114. TCgSize = (OS_NO,
  115. { integer registers }
  116. OS_8,OS_16,OS_32,OS_64,OS_128,OS_S8,OS_S16,OS_S32,OS_S64,OS_S128,
  117. { single,double,extended,comp,float128 }
  118. OS_F32,OS_F64,OS_F80,OS_C64,OS_F128,
  119. { multi-media sizes: split in byte, word, dword, ... }
  120. { entities, then the signed counterparts }
  121. OS_M8,OS_M16,OS_M32,OS_M64,OS_M128,
  122. OS_MS8,OS_MS16,OS_MS32,OS_MS64,OS_MS128);
  123. { Register types }
  124. TRegisterType = (
  125. R_INVALIDREGISTER, { = 0 }
  126. R_INTREGISTER, { = 1 }
  127. R_FPUREGISTER, { = 2 }
  128. { used by Intel only }
  129. R_MMXREGISTER, { = 3 }
  130. R_MMREGISTER, { = 4 }
  131. R_SPECIALREGISTER, { = 5 }
  132. R_ADDRESSREGISTER { = 6 }
  133. );
  134. { Sub registers }
  135. TSubRegister = (
  136. R_SUBNONE, { = 0; no sub register possible }
  137. R_SUBL, { = 1; 8 bits, Like AL }
  138. R_SUBH, { = 2; 8 bits, Like AH }
  139. R_SUBW, { = 3; 16 bits, Like AX }
  140. R_SUBD, { = 4; 32 bits, Like EAX }
  141. R_SUBQ, { = 5; 64 bits, Like RAX }
  142. { For Sparc floats that use F0:F1 to store doubles }
  143. R_SUBFS, { = 6; Float that allocates 1 FPU register }
  144. R_SUBFD, { = 7; Float that allocates 2 FPU registers }
  145. R_SUBFQ, { = 8; Float that allocates 4 FPU registers }
  146. R_SUBMMS, { = 9; single scalar in multi media register }
  147. R_SUBMMD, { = 10; double scalar in multi media register }
  148. R_SUBMMWHOLE { = 11; complete MM register, size depends on CPU }
  149. );
  150. TSuperRegister = type word;
  151. {
  152. The new register coding:
  153. SuperRegister (bits 0..15)
  154. Subregister (bits 16..23)
  155. Register type (bits 24..31)
  156. TRegister is defined as an enum to make it incompatible
  157. with TSuperRegister to avoid mixing them
  158. }
  159. TRegister = (
  160. TRegisterLowEnum := Low(longint),
  161. TRegisterHighEnum := High(longint)
  162. );
  163. TRegisterRec=packed record
  164. {$ifdef FPC_BIG_ENDIAN}
  165. regtype : Tregistertype;
  166. subreg : Tsubregister;
  167. supreg : Tsuperregister;
  168. {$else FPC_BIG_ENDIAN}
  169. supreg : Tsuperregister;
  170. subreg : Tsubregister;
  171. regtype : Tregistertype;
  172. {$endif FPC_BIG_ENDIAN}
  173. end;
  174. { A type to store register locations for 64 Bit values. }
  175. {$ifdef cpu64bitalu}
  176. tregister64 = tregister;
  177. {$else cpu64bitalu}
  178. tregister64 = record
  179. reglo,reghi : tregister;
  180. end;
  181. {$endif cpu64bitalu}
  182. Tregistermmxset = record
  183. reg0,reg1,reg2,reg3:Tregister
  184. end;
  185. { Set type definition for registers }
  186. tcpuregisterset = set of byte;
  187. tsuperregisterset = array[byte] of set of byte;
  188. pmmshuffle = ^tmmshuffle;
  189. { this record describes shuffle operations for mm operations; if a pointer a shuffle record
  190. passed to an mm operation is nil, it means that the whole location is moved }
  191. tmmshuffle = record
  192. { describes how many shuffles are actually described, if len=0 then
  193. moving the scalar with index 0 to the scalar with index 0 is meant }
  194. len : byte;
  195. { lower nibble of each entry of this array describes index of the source data index while
  196. the upper nibble describes the destination index }
  197. shuffles : array[1..1] of byte;
  198. end;
  199. Tsuperregisterarray=array[0..$ffff] of Tsuperregister;
  200. Psuperregisterarray=^Tsuperregisterarray;
  201. Tsuperregisterworklist=object
  202. buflength,
  203. buflengthinc,
  204. length:word;
  205. buf:Psuperregisterarray;
  206. constructor init;
  207. constructor copyfrom(const x:Tsuperregisterworklist);
  208. destructor done;
  209. procedure clear;
  210. procedure add(s:tsuperregister);
  211. function addnodup(s:tsuperregister): boolean;
  212. function get:tsuperregister;
  213. function readidx(i:word):tsuperregister;
  214. procedure deleteidx(i:word);
  215. function delete(s:tsuperregister):boolean;
  216. end;
  217. psuperregisterworklist=^tsuperregisterworklist;
  218. const
  219. { alias for easier understanding }
  220. R_SSEREGISTER = R_MMREGISTER;
  221. { Invalid register number }
  222. RS_INVALID = high(tsuperregister);
  223. { Maximum number of cpu registers per register type,
  224. this must fit in tcpuregisterset }
  225. maxcpuregister = 32;
  226. tcgsize2size : Array[tcgsize] of integer =
  227. { integer values }
  228. (0,1,2,4,8,16,1,2,4,8,16,
  229. { floating point values }
  230. 4,8,10,8,16,
  231. { multimedia values }
  232. 1,2,4,8,16,1,2,4,8,16);
  233. tfloat2tcgsize: array[tfloattype] of tcgsize =
  234. (OS_F32,OS_F64,OS_F80,OS_C64,OS_C64,OS_F128);
  235. tcgsize2tfloat: array[OS_F32..OS_C64] of tfloattype =
  236. (s32real,s64real,s80real,s64comp);
  237. tvarregable2tcgloc : array[tvarregable] of tcgloc = (LOC_VOID,
  238. LOC_CREGISTER,LOC_CFPUREGISTER,LOC_CMMREGISTER,LOC_CREGISTER);
  239. { Table to convert tcgsize variables to the correspondending
  240. unsigned types }
  241. tcgsize2unsigned : array[tcgsize] of tcgsize = (OS_NO,
  242. OS_8,OS_16,OS_32,OS_64,OS_128,OS_8,OS_16,OS_32,OS_64,OS_128,
  243. OS_F32,OS_F64,OS_F80,OS_C64,OS_F128,
  244. OS_M8,OS_M16,OS_M32,OS_M64,OS_M128,OS_M8,OS_M16,OS_M32,
  245. OS_M64,OS_M128);
  246. tcgloc2str : array[TCGLoc] of string[12] = (
  247. 'LOC_INVALID',
  248. 'LOC_VOID',
  249. 'LOC_CONST',
  250. 'LOC_JUMP',
  251. 'LOC_FLAGS',
  252. 'LOC_CREF',
  253. 'LOC_REF',
  254. 'LOC_REG',
  255. 'LOC_CREG',
  256. 'LOC_FPUREG',
  257. 'LOC_CFPUREG',
  258. 'LOC_MMXREG',
  259. 'LOC_CMMXREG',
  260. 'LOC_MMREG',
  261. 'LOC_CMMREG',
  262. 'LOC_SSETREG',
  263. 'LOC_CSSETREG',
  264. 'LOC_SSETREF',
  265. 'LOC_CSSETREF');
  266. var
  267. mms_movescalar : pmmshuffle;
  268. procedure supregset_reset(var regs:tsuperregisterset;setall:boolean;
  269. maxreg:Tsuperregister);{$ifdef USEINLINE}inline;{$endif}
  270. procedure supregset_include(var regs:tsuperregisterset;s:tsuperregister);{$ifdef USEINLINE}inline;{$endif}
  271. procedure supregset_exclude(var regs:tsuperregisterset;s:tsuperregister);{$ifdef USEINLINE}inline;{$endif}
  272. function supregset_in(const regs:tsuperregisterset;s:tsuperregister):boolean;{$ifdef USEINLINE}inline;{$endif}
  273. function newreg(rt:tregistertype;sr:tsuperregister;sb:tsubregister):tregister;{$ifdef USEINLINE}inline;{$endif}
  274. function getsubreg(r:tregister):tsubregister;{$ifdef USEINLINE}inline;{$endif}
  275. function getsupreg(r:tregister):tsuperregister;{$ifdef USEINLINE}inline;{$endif}
  276. function getregtype(r:tregister):tregistertype;{$ifdef USEINLINE}inline;{$endif}
  277. procedure setsubreg(var r:tregister;sr:tsubregister);{$ifdef USEINLINE}inline;{$endif}
  278. procedure setsupreg(var r:tregister;sr:tsuperregister);{$ifdef USEINLINE}inline;{$endif}
  279. function generic_regname(r:tregister):string;
  280. function isaddressregister(reg : tregister) : boolean; {$ifdef USEINLINE} inline; {$endif}
  281. {# From a constant numeric value, return the abstract code generator
  282. size.
  283. }
  284. function int_cgsize(const a: aint): tcgsize;{$ifdef USEINLINE}inline;{$endif}
  285. function int_float_cgsize(const a: aint): tcgsize;
  286. { return the inverse condition of opcmp }
  287. function inverse_opcmp(opcmp: topcmp): topcmp;{$ifdef USEINLINE}inline;{$endif}
  288. { return the opcmp needed when swapping the operands }
  289. function swap_opcmp(opcmp: topcmp): topcmp;{$ifdef USEINLINE}inline;{$endif}
  290. { return whether op is commutative }
  291. function commutativeop(op: topcg): boolean;{$ifdef USEINLINE}inline;{$endif}
  292. { returns true, if shuffle describes a real shuffle operation and not only a move }
  293. function realshuffle(shuffle : pmmshuffle) : boolean;
  294. { returns true, if the shuffle describes only a move of the scalar at index 0 }
  295. function shufflescalar(shuffle : pmmshuffle) : boolean;
  296. { removes shuffling from shuffle, this means that the destenation index of each shuffle is copied to
  297. the source }
  298. procedure removeshuffles(var shuffle : tmmshuffle);
  299. implementation
  300. uses
  301. verbose;
  302. {******************************************************************************
  303. tsuperregisterworklist
  304. ******************************************************************************}
  305. constructor tsuperregisterworklist.init;
  306. begin
  307. length:=0;
  308. buflength:=0;
  309. buflengthinc:=16;
  310. buf:=nil;
  311. end;
  312. constructor Tsuperregisterworklist.copyfrom(const x:Tsuperregisterworklist);
  313. begin
  314. self:=x;
  315. if x.buf<>nil then
  316. begin
  317. getmem(buf,buflength*sizeof(Tsuperregister));
  318. move(x.buf^,buf^,length*sizeof(Tsuperregister));
  319. end;
  320. end;
  321. destructor tsuperregisterworklist.done;
  322. begin
  323. if assigned(buf) then
  324. freemem(buf);
  325. end;
  326. procedure tsuperregisterworklist.add(s:tsuperregister);
  327. begin
  328. inc(length);
  329. { Need to increase buffer length? }
  330. if length>=buflength then
  331. begin
  332. inc(buflength,buflengthinc);
  333. buflengthinc:=buflengthinc*2;
  334. if buflengthinc>256 then
  335. buflengthinc:=256;
  336. reallocmem(buf,buflength*sizeof(Tsuperregister));
  337. end;
  338. buf^[length-1]:=s;
  339. end;
  340. function tsuperregisterworklist.addnodup(s:tsuperregister): boolean;
  341. begin
  342. addnodup := false;
  343. if indexword(buf^,length,s) = -1 then
  344. begin
  345. add(s);
  346. addnodup := true;
  347. end;
  348. end;
  349. procedure tsuperregisterworklist.clear;
  350. begin
  351. length:=0;
  352. end;
  353. procedure tsuperregisterworklist.deleteidx(i:word);
  354. begin
  355. if i>=length then
  356. internalerror(200310144);
  357. buf^[i]:=buf^[length-1];
  358. dec(length);
  359. end;
  360. function tsuperregisterworklist.readidx(i:word):tsuperregister;
  361. begin
  362. if (i >= length) then
  363. internalerror(2005010601);
  364. result := buf^[i];
  365. end;
  366. function tsuperregisterworklist.get:tsuperregister;
  367. begin
  368. if length=0 then
  369. internalerror(200310142);
  370. get:=buf^[0];
  371. buf^[0]:=buf^[length-1];
  372. dec(length);
  373. end;
  374. function tsuperregisterworklist.delete(s:tsuperregister):boolean;
  375. var
  376. i:longint;
  377. begin
  378. delete:=false;
  379. { indexword in 1.0.x and 1.9.4 is broken }
  380. i:=indexword(buf^,length,s);
  381. if i<>-1 then
  382. begin
  383. deleteidx(i);
  384. delete := true;
  385. end;
  386. end;
  387. procedure supregset_reset(var regs:tsuperregisterset;setall:boolean;
  388. maxreg:Tsuperregister);{$ifdef USEINLINE}inline;{$endif}
  389. begin
  390. fillchar(regs,(maxreg+7) shr 3,-byte(setall));
  391. end;
  392. procedure supregset_include(var regs:tsuperregisterset;s:tsuperregister);{$ifdef USEINLINE}inline;{$endif}
  393. begin
  394. include(regs[s shr 8],(s and $ff));
  395. end;
  396. procedure supregset_exclude(var regs:tsuperregisterset;s:tsuperregister);{$ifdef USEINLINE}inline;{$endif}
  397. begin
  398. exclude(regs[s shr 8],(s and $ff));
  399. end;
  400. function supregset_in(const regs:tsuperregisterset;s:tsuperregister):boolean;{$ifdef USEINLINE}inline;{$endif}
  401. begin
  402. result:=(s and $ff) in regs[s shr 8];
  403. end;
  404. function newreg(rt:tregistertype;sr:tsuperregister;sb:tsubregister):tregister;{$ifdef USEINLINE}inline;{$endif}
  405. begin
  406. tregisterrec(result).regtype:=rt;
  407. tregisterrec(result).supreg:=sr;
  408. tregisterrec(result).subreg:=sb;
  409. end;
  410. function getsubreg(r:tregister):tsubregister;{$ifdef USEINLINE}inline;{$endif}
  411. begin
  412. result:=tregisterrec(r).subreg;
  413. end;
  414. function getsupreg(r:tregister):tsuperregister;{$ifdef USEINLINE}inline;{$endif}
  415. begin
  416. result:=tregisterrec(r).supreg;
  417. end;
  418. function getregtype(r:tregister):tregistertype;{$ifdef USEINLINE}inline;{$endif}
  419. begin
  420. result:=tregisterrec(r).regtype;
  421. end;
  422. procedure setsubreg(var r:tregister;sr:tsubregister);{$ifdef USEINLINE}inline;{$endif}
  423. begin
  424. tregisterrec(r).subreg:=sr;
  425. end;
  426. procedure setsupreg(var r:tregister;sr:tsuperregister);{$ifdef USEINLINE}inline;{$endif}
  427. begin
  428. tregisterrec(r).supreg:=sr;
  429. end;
  430. function generic_regname(r:tregister):string;
  431. var
  432. nr : string[12];
  433. begin
  434. str(getsupreg(r),nr);
  435. case getregtype(r) of
  436. R_INTREGISTER:
  437. result:='ireg'+nr;
  438. R_FPUREGISTER:
  439. result:='freg'+nr;
  440. R_MMREGISTER:
  441. result:='mreg'+nr;
  442. R_MMXREGISTER:
  443. result:='xreg'+nr;
  444. R_ADDRESSREGISTER:
  445. result:='areg'+nr;
  446. R_SPECIALREGISTER:
  447. result:='sreg'+nr;
  448. else
  449. begin
  450. result:='INVALID';
  451. exit;
  452. end;
  453. end;
  454. case getsubreg(r) of
  455. R_SUBNONE:
  456. ;
  457. R_SUBL:
  458. result:=result+'l';
  459. R_SUBH:
  460. result:=result+'h';
  461. R_SUBW:
  462. result:=result+'w';
  463. R_SUBD:
  464. result:=result+'d';
  465. R_SUBQ:
  466. result:=result+'q';
  467. R_SUBFS:
  468. result:=result+'fs';
  469. R_SUBFD:
  470. result:=result+'fd';
  471. R_SUBMMD:
  472. result:=result+'md';
  473. R_SUBMMS:
  474. result:=result+'ms';
  475. R_SUBMMWHOLE:
  476. result:=result+'ma';
  477. else
  478. internalerror(200308252);
  479. end;
  480. end;
  481. function isaddressregister(reg : tregister) : boolean;
  482. begin
  483. result:=getregtype(reg)=R_ADDRESSREGISTER;
  484. end;
  485. function int_cgsize(const a: aint): tcgsize;{$ifdef USEINLINE}inline;{$endif}
  486. const
  487. size2cgsize : array[0..8] of tcgsize = (
  488. OS_NO,OS_8,OS_16,OS_NO,OS_32,OS_NO,OS_NO,OS_NO,OS_64
  489. );
  490. begin
  491. if a>8 then
  492. result:=OS_NO
  493. else
  494. result:=size2cgsize[a];
  495. end;
  496. function int_float_cgsize(const a: aint): tcgsize;
  497. begin
  498. case a of
  499. 4 :
  500. result:=OS_F32;
  501. 8 :
  502. result:=OS_F64;
  503. 10 :
  504. result:=OS_F80;
  505. 16 :
  506. result:=OS_F128;
  507. else
  508. internalerror(200603211);
  509. end;
  510. end;
  511. function inverse_opcmp(opcmp: topcmp): topcmp;{$ifdef USEINLINE}inline;{$endif}
  512. const
  513. list: array[TOpCmp] of TOpCmp =
  514. (OC_NONE,OC_NE,OC_LTE,OC_GTE,OC_LT,OC_GT,OC_EQ,OC_A,OC_AE,
  515. OC_B,OC_BE);
  516. begin
  517. inverse_opcmp := list[opcmp];
  518. end;
  519. function swap_opcmp(opcmp: topcmp): topcmp;{$ifdef USEINLINE}inline;{$endif}
  520. const
  521. list: array[TOpCmp] of TOpCmp =
  522. (OC_NONE,OC_EQ,OC_LT,OC_GT,OC_LTE,OC_GTE,OC_NE,OC_AE,OC_A,
  523. OC_BE,OC_B);
  524. begin
  525. swap_opcmp := list[opcmp];
  526. end;
  527. function commutativeop(op: topcg): boolean;{$ifdef USEINLINE}inline;{$endif}
  528. const
  529. list: array[topcg] of boolean =
  530. (true,false,true,true,false,false,true,true,false,false,
  531. true,false,false,false,false,true,false,false);
  532. begin
  533. commutativeop := list[op];
  534. end;
  535. function realshuffle(shuffle : pmmshuffle) : boolean;
  536. var
  537. i : longint;
  538. begin
  539. realshuffle:=true;
  540. if (shuffle=nil) or (shuffle^.len=0) then
  541. realshuffle:=false
  542. else
  543. begin
  544. for i:=1 to shuffle^.len do
  545. begin
  546. if (shuffle^.shuffles[i] and $f)<>((shuffle^.shuffles[i] and $f0) shr 4) then
  547. exit;
  548. end;
  549. realshuffle:=false;
  550. end;
  551. end;
  552. function shufflescalar(shuffle : pmmshuffle) : boolean;
  553. begin
  554. result:=shuffle^.len=0;
  555. end;
  556. procedure removeshuffles(var shuffle : tmmshuffle);
  557. var
  558. i : longint;
  559. begin
  560. if shuffle.len=0 then
  561. exit;
  562. for i:=1 to shuffle.len do
  563. shuffle.shuffles[i]:=(shuffle.shuffles[i] and $f) or ((shuffle.shuffles[i] and $f0) shr 4);
  564. end;
  565. initialization
  566. new(mms_movescalar);
  567. mms_movescalar^.len:=0;
  568. finalization
  569. dispose(mms_movescalar);
  570. end.