raavrgas.pas 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745
  1. {
  2. Copyright (c) 1998-2008 by Carl Eric Codere and Peter Vreman
  3. Does the parsing for the ARM GNU AS styled inline assembler.
  4. This program is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation; either version 2 of the License, or
  7. (at your option) any later version.
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. GNU General Public License for more details.
  12. You should have received a copy of the GNU General Public License
  13. along with this program; if not, write to the Free Software
  14. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  15. ****************************************************************************
  16. }
  17. Unit raavrgas;
  18. {$i fpcdefs.inc}
  19. Interface
  20. uses
  21. raatt,raavr,
  22. cpubase;
  23. type
  24. tavrattreader = class(tattreader)
  25. function is_asmopcode(const s: string):boolean;override;
  26. function is_register(const s:string):boolean;override;
  27. procedure handleopcode;override;
  28. procedure BuildReference(oper : tavroperand);
  29. procedure BuildOperand(oper : tavroperand);
  30. procedure BuildOpCode(instr : tavrinstruction);
  31. procedure ReadSym(oper : tavroperand);
  32. procedure ConvertCalljmp(instr : tavrinstruction);
  33. end;
  34. Implementation
  35. uses
  36. { helpers }
  37. cutils,
  38. { global }
  39. globtype,globals,verbose,
  40. systems,
  41. { aasm }
  42. cpuinfo,aasmbase,aasmtai,aasmdata,aasmcpu,
  43. { symtable }
  44. symconst,symbase,symtype,symsym,symtable,symdef,
  45. { parser }
  46. scanner,
  47. procinfo,
  48. itcpugas,
  49. rabase,rautils,
  50. cgbase,cgutils,cgobj,paramgr
  51. ;
  52. function tavrattreader.is_register(const s:string):boolean;
  53. type
  54. treg2str = record
  55. name : string[2];
  56. reg : tregister;
  57. end;
  58. const
  59. extraregs : array[0..5] of treg2str = (
  60. (name: 'XL'; reg : NR_R26),
  61. (name: 'XH'; reg : NR_R27),
  62. (name: 'YL'; reg : NR_R28),
  63. (name: 'YH'; reg : NR_R29),
  64. (name: 'ZL'; reg : NR_R30),
  65. (name: 'ZH'; reg : NR_R31)
  66. );
  67. var
  68. i : longint;
  69. begin
  70. result:=inherited is_register(s);
  71. { reg found?
  72. possible aliases are always 2 char
  73. }
  74. if result or (not (length(s) in [1,2])) then
  75. exit;
  76. for i:=low(extraregs) to high(extraregs) do
  77. begin
  78. if s=extraregs[i].name then
  79. begin
  80. actasmregister:=extraregs[i].reg;
  81. result:=true;
  82. actasmtoken:=AS_REGISTER;
  83. exit;
  84. end;
  85. end;
  86. end;
  87. procedure tavrattreader.ReadSym(oper : tavroperand);
  88. var
  89. tempstr, mangledname : string;
  90. typesize : tcgint;
  91. l,k : tcgint;
  92. begin
  93. tempstr:=actasmpattern;
  94. Consume(AS_ID);
  95. { typecasting? }
  96. if (actasmtoken=AS_LPAREN) and
  97. SearchType(tempstr,typesize) then
  98. begin
  99. oper.hastype:=true;
  100. Consume(AS_LPAREN);
  101. BuildOperand(oper);
  102. Consume(AS_RPAREN);
  103. if oper.opr.typ in [OPR_REFERENCE,OPR_LOCAL] then
  104. oper.SetSize(typesize,true);
  105. end
  106. else
  107. if not oper.SetupVar(tempstr,false) then
  108. Message1(sym_e_unknown_id,tempstr);
  109. { record.field ? }
  110. if actasmtoken=AS_DOT then
  111. begin
  112. BuildRecordOffsetSize(tempstr,l,k,mangledname,false);
  113. if (mangledname<>'') then
  114. Message(asmr_e_invalid_reference_syntax);
  115. inc(oper.opr.ref.offset,l);
  116. end;
  117. end;
  118. Procedure tavrattreader.BuildReference(oper : tavroperand);
  119. procedure Consume_RParen;
  120. begin
  121. if actasmtoken<>AS_RPAREN then
  122. Begin
  123. Message(asmr_e_invalid_reference_syntax);
  124. RecoverConsume(true);
  125. end
  126. else
  127. begin
  128. Consume(AS_RPAREN);
  129. if not (actasmtoken in [AS_COMMA,AS_SEPARATOR,AS_END]) then
  130. Begin
  131. Message(asmr_e_invalid_reference_syntax);
  132. RecoverConsume(true);
  133. end;
  134. end;
  135. end;
  136. procedure read_index;
  137. begin
  138. Consume(AS_COMMA);
  139. if actasmtoken=AS_REGISTER then
  140. Begin
  141. oper.opr.ref.index:=actasmregister;
  142. Consume(AS_REGISTER);
  143. end
  144. else if actasmtoken=AS_HASH then
  145. begin
  146. Consume(AS_HASH);
  147. inc(oper.opr.ref.offset,BuildConstExpression(false,true));
  148. end;
  149. end;
  150. begin
  151. Consume(AS_LPAREN);
  152. if actasmtoken=AS_REGISTER then
  153. begin
  154. oper.opr.ref.base:=actasmregister;
  155. Consume(AS_REGISTER);
  156. { can either be a register or a right parenthesis }
  157. { (reg) }
  158. if actasmtoken=AS_LPAREN then
  159. Begin
  160. Consume_RParen;
  161. exit;
  162. end;
  163. if actasmtoken=AS_PLUS then
  164. begin
  165. consume(AS_PLUS);
  166. oper.opr.ref.addressmode:=AM_POSTINCREMENT;
  167. end;
  168. end {end case }
  169. else
  170. Begin
  171. Message(asmr_e_invalid_reference_syntax);
  172. RecoverConsume(false);
  173. end;
  174. end;
  175. Procedure tavrattreader.BuildOperand(oper : tavroperand);
  176. var
  177. expr : string;
  178. typesize,l : tcgint;
  179. procedure AddLabelOperand(hl:tasmlabel);
  180. begin
  181. if not(actasmtoken in [AS_PLUS,AS_MINUS,AS_LPAREN]) { and
  182. is_calljmp(actopcode) } then
  183. begin
  184. oper.opr.typ:=OPR_SYMBOL;
  185. oper.opr.symbol:=hl;
  186. end
  187. else
  188. begin
  189. oper.InitRef;
  190. oper.opr.ref.symbol:=hl;
  191. end;
  192. end;
  193. procedure MaybeRecordOffset;
  194. var
  195. mangledname: string;
  196. hasdot : boolean;
  197. l,
  198. toffset,
  199. tsize : tcgint;
  200. begin
  201. if not(actasmtoken in [AS_DOT,AS_PLUS,AS_MINUS]) then
  202. exit;
  203. l:=0;
  204. mangledname:='';
  205. hasdot:=(actasmtoken=AS_DOT);
  206. if hasdot then
  207. begin
  208. if expr<>'' then
  209. begin
  210. BuildRecordOffsetSize(expr,toffset,tsize,mangledname,false);
  211. if (oper.opr.typ<>OPR_CONSTANT) and
  212. (mangledname<>'') then
  213. Message(asmr_e_wrong_sym_type);
  214. inc(l,toffset);
  215. oper.SetSize(tsize,true);
  216. end;
  217. end;
  218. if actasmtoken in [AS_PLUS,AS_MINUS] then
  219. inc(l,BuildConstExpression(true,false));
  220. case oper.opr.typ of
  221. OPR_LOCAL :
  222. begin
  223. { don't allow direct access to fields of parameters, because that
  224. will generate buggy code. Allow it only for explicit typecasting }
  225. if hasdot and
  226. (not oper.hastype) then
  227. checklocalsubscript(oper.opr.localsym);
  228. inc(oper.opr.localsymofs,l)
  229. end;
  230. OPR_CONSTANT :
  231. inc(oper.opr.val,l);
  232. OPR_REFERENCE :
  233. if (mangledname<>'') then
  234. begin
  235. if (oper.opr.val<>0) then
  236. Message(asmr_e_wrong_sym_type);
  237. oper.opr.typ:=OPR_SYMBOL;
  238. oper.opr.symbol:=current_asmdata.RefAsmSymbol(mangledname,AT_FUNCTION);
  239. end
  240. else
  241. inc(oper.opr.val,l);
  242. OPR_SYMBOL:
  243. Message(asmr_e_invalid_symbol_ref);
  244. else
  245. internalerror(200309221);
  246. end;
  247. end;
  248. function MaybeBuildReference:boolean;
  249. { Try to create a reference, if not a reference is found then false
  250. is returned }
  251. begin
  252. MaybeBuildReference:=true;
  253. case actasmtoken of
  254. AS_INTNUM,
  255. AS_MINUS,
  256. AS_PLUS:
  257. Begin
  258. oper.opr.ref.offset:=BuildConstExpression(True,False);
  259. case actasmtoken of
  260. AS_LPAREN:
  261. BuildReference(oper);
  262. AS_COMMA:
  263. exit;
  264. else
  265. Message(asmr_e_invalid_reference_syntax)
  266. end;
  267. end;
  268. AS_LPAREN:
  269. BuildReference(oper);
  270. AS_ID: { only a variable is allowed ... }
  271. Begin
  272. ReadSym(oper);
  273. case actasmtoken of
  274. AS_END,
  275. AS_SEPARATOR,
  276. AS_COMMA: ;
  277. AS_LPAREN:
  278. BuildReference(oper);
  279. else
  280. Begin
  281. Message(asmr_e_invalid_reference_syntax);
  282. Consume(actasmtoken);
  283. end;
  284. end; {end case }
  285. end;
  286. else
  287. MaybeBuildReference:=false;
  288. end; { end case }
  289. end;
  290. var
  291. tempreg : tregister;
  292. ireg : tsuperregister;
  293. hl : tasmlabel;
  294. ofs : longint;
  295. registerset : tcpuregisterset;
  296. tempstr : string;
  297. tempsymtyp : tasmsymtype;
  298. Begin
  299. expr:='';
  300. case actasmtoken of
  301. AS_LBRACKET: { Memory reference or constant expression }
  302. Begin
  303. oper.InitRef;
  304. BuildReference(oper);
  305. end;
  306. AS_INTNUM,
  307. AS_MINUS,
  308. AS_PLUS:
  309. Begin
  310. if (actasmtoken=AS_MINUS) and
  311. (actopcode in [A_LD,A_ST]) then
  312. begin
  313. { Special handling of predecrement addressing }
  314. oper.InitRef;
  315. oper.opr.ref.addressmode:=AM_PREDRECEMENT;
  316. consume(AS_MINUS);
  317. if actasmtoken=AS_REGISTER then
  318. begin
  319. oper.opr.ref.base:=actasmregister;
  320. consume(AS_REGISTER);
  321. end
  322. else
  323. begin
  324. Message(asmr_e_invalid_reference_syntax);
  325. RecoverConsume(false);
  326. end;
  327. end
  328. else
  329. begin
  330. { Constant memory offset }
  331. { This must absolutely be followed by ( }
  332. oper.InitRef;
  333. oper.opr.ref.offset:=BuildConstExpression(True,False);
  334. { absolute memory addresss? }
  335. if ((actopcode = A_LDS) and (actasmtoken <> AS_SEPARATOR)) or
  336. ((actopcode = A_STS) and (actasmtoken <> AS_COMMA)) then
  337. begin
  338. if not(MaybeBuildReference) then
  339. Message(asmr_e_invalid_reference_syntax);
  340. end
  341. else
  342. begin
  343. ofs:=oper.opr.ref.offset;
  344. BuildConstantOperand(oper);
  345. inc(oper.opr.val,ofs);
  346. end;
  347. end;
  348. end;
  349. AS_ID: { A constant expression, or a Variable ref. }
  350. Begin
  351. if (actasmpattern='LO8') or (actasmpattern='HI8') then
  352. begin
  353. { Low or High part of a constant (or constant
  354. memory location) }
  355. oper.InitRef;
  356. if actasmpattern='LO8' then
  357. oper.opr.ref.refaddr:=addr_lo8
  358. else
  359. oper.opr.ref.refaddr:=addr_hi8;
  360. Consume(actasmtoken);
  361. Consume(AS_LPAREN);
  362. BuildConstSymbolExpression(false, true,false,l,tempstr,tempsymtyp);
  363. if not assigned(oper.opr.ref.symbol) then
  364. oper.opr.ref.symbol:=current_asmdata.RefAsmSymbol(tempstr,tempsymtyp)
  365. else
  366. Message(asmr_e_cant_have_multiple_relocatable_symbols);
  367. case oper.opr.typ of
  368. OPR_CONSTANT :
  369. inc(oper.opr.val,l);
  370. OPR_LOCAL :
  371. inc(oper.opr.localsymofs,l);
  372. OPR_REFERENCE :
  373. inc(oper.opr.ref.offset,l);
  374. else
  375. internalerror(200309202);
  376. end;
  377. Consume(AS_RPAREN);
  378. end
  379. { Local Label ? }
  380. else if is_locallabel(actasmpattern) then
  381. begin
  382. CreateLocalLabel(actasmpattern,hl,false);
  383. Consume(AS_ID);
  384. AddLabelOperand(hl);
  385. end
  386. { Check for label }
  387. else if SearchLabel(actasmpattern,hl,false) then
  388. begin
  389. Consume(AS_ID);
  390. AddLabelOperand(hl);
  391. end
  392. else
  393. { probably a variable or normal expression }
  394. { or a procedure (such as in CALL ID) }
  395. Begin
  396. { is it a constant ? }
  397. if SearchIConstant(actasmpattern,l) then
  398. Begin
  399. if not (oper.opr.typ in [OPR_NONE,OPR_CONSTANT]) then
  400. Message(asmr_e_invalid_operand_type);
  401. BuildConstantOperand(oper);
  402. end
  403. else
  404. begin
  405. expr:=actasmpattern;
  406. Consume(AS_ID);
  407. { typecasting? }
  408. if (actasmtoken=AS_LPAREN) and
  409. SearchType(expr,typesize) then
  410. begin
  411. oper.hastype:=true;
  412. Consume(AS_LPAREN);
  413. BuildOperand(oper);
  414. Consume(AS_RPAREN);
  415. if oper.opr.typ in [OPR_REFERENCE,OPR_LOCAL] then
  416. oper.SetSize(typesize,true);
  417. end
  418. else
  419. begin
  420. if not(oper.SetupVar(expr,false)) then
  421. Begin
  422. { look for special symbols ... }
  423. if expr= '__HIGH' then
  424. begin
  425. consume(AS_LPAREN);
  426. if not oper.setupvar('high'+actasmpattern,false) then
  427. Message1(sym_e_unknown_id,'high'+actasmpattern);
  428. consume(AS_ID);
  429. consume(AS_RPAREN);
  430. end
  431. else
  432. if expr = '__RESULT' then
  433. oper.SetUpResult
  434. else
  435. if expr = '__SELF' then
  436. oper.SetupSelf
  437. else
  438. if expr = '__OLDEBP' then
  439. oper.SetupOldEBP
  440. else
  441. Message1(sym_e_unknown_id,expr);
  442. end;
  443. end;
  444. end;
  445. if actasmtoken=AS_DOT then
  446. MaybeRecordOffset;
  447. { add a constant expression? }
  448. if (actasmtoken=AS_PLUS) then
  449. begin
  450. l:=BuildConstExpression(true,false);
  451. case oper.opr.typ of
  452. OPR_CONSTANT :
  453. inc(oper.opr.val,l);
  454. OPR_LOCAL :
  455. inc(oper.opr.localsymofs,l);
  456. OPR_REFERENCE :
  457. inc(oper.opr.ref.offset,l);
  458. else
  459. internalerror(200309202);
  460. end;
  461. end
  462. end;
  463. { Do we have a indexing reference, then parse it also }
  464. if actasmtoken=AS_LPAREN then
  465. BuildReference(oper);
  466. end;
  467. { Register, a variable reference or a constant reference }
  468. AS_REGISTER:
  469. Begin
  470. { save the type of register used. }
  471. tempreg:=actasmregister;
  472. Consume(AS_REGISTER);
  473. if (actasmtoken=AS_PLUS) then
  474. begin
  475. oper.opr.typ:=OPR_REFERENCE;
  476. reference_reset_base(oper.opr.ref,tempreg,0,1,[]);
  477. { add a constant expression? }
  478. if actasmtoken=AS_PLUS then
  479. begin
  480. consume(AS_PLUS);
  481. if actasmtoken in [AS_INTNUM,AS_ID] then
  482. begin
  483. l:=BuildConstExpression(true,false);
  484. inc(oper.opr.ref.offset,l);
  485. end
  486. else
  487. oper.opr.ref.addressmode:=AM_POSTINCREMENT;
  488. end;
  489. end
  490. else if (actasmtoken in [AS_END,AS_SEPARATOR,AS_COMMA]) then
  491. Begin
  492. if not (oper.opr.typ in [OPR_NONE,OPR_REGISTER]) then
  493. Message(asmr_e_invalid_operand_type);
  494. oper.opr.typ:=OPR_REGISTER;
  495. oper.opr.reg:=tempreg;
  496. end
  497. else
  498. Message(asmr_e_syn_operand);
  499. end;
  500. AS_END,
  501. AS_SEPARATOR,
  502. AS_COMMA: ;
  503. else
  504. Begin
  505. Message(asmr_e_syn_operand);
  506. Consume(actasmtoken);
  507. end;
  508. end; { end case }
  509. end;
  510. {*****************************************************************************
  511. tavrattreader
  512. *****************************************************************************}
  513. procedure tavrattreader.BuildOpCode(instr : tavrinstruction);
  514. var
  515. operandnum : longint;
  516. Begin
  517. { opcode }
  518. if (actasmtoken<>AS_OPCODE) then
  519. Begin
  520. Message(asmr_e_invalid_or_missing_opcode);
  521. RecoverConsume(true);
  522. exit;
  523. end;
  524. { Fill the instr object with the current state }
  525. with instr do
  526. begin
  527. Opcode:=ActOpcode;
  528. condition:=ActCondition;
  529. end;
  530. { We are reading operands, so opcode will be an AS_ID }
  531. operandnum:=1;
  532. Consume(AS_OPCODE);
  533. { Zero operand opcode ? }
  534. if actasmtoken in [AS_SEPARATOR,AS_END] then
  535. begin
  536. operandnum:=0;
  537. exit;
  538. end;
  539. { Read the operands }
  540. repeat
  541. case actasmtoken of
  542. AS_COMMA: { Operand delimiter }
  543. Begin
  544. if operandnum>Max_Operands then
  545. Message(asmr_e_too_many_operands)
  546. else
  547. Inc(operandnum);
  548. Consume(AS_COMMA);
  549. end;
  550. AS_SEPARATOR,
  551. AS_END : { End of asm operands for this opcode }
  552. begin
  553. break;
  554. end;
  555. else
  556. BuildOperand(instr.Operands[operandnum] as tavroperand);
  557. end; { end case }
  558. until false;
  559. instr.Ops:=operandnum;
  560. end;
  561. function tavrattreader.is_asmopcode(const s: string):boolean;
  562. const
  563. { sorted by length so longer postfixes will match first }
  564. postfix2strsorted : array[1..19] of string[2] = (
  565. 'EP','SB','BT','SH',
  566. 'IA','IB','DA','DB','FD','FA','ED','EA',
  567. 'B','D','E','P','T','H','S');
  568. var
  569. len,
  570. j,
  571. sufidx : longint;
  572. hs : string;
  573. maxlen : longint;
  574. icond : tasmcond;
  575. Begin
  576. { making s a value parameter would break other assembler readers }
  577. hs:=s;
  578. is_asmopcode:=false;
  579. { clear op code }
  580. actopcode:=A_None;
  581. actcondition:=C_None;
  582. { first, handle B else BLS is read wrong }
  583. if ((copy(hs,1,2)='BR') and (length(hs)=4)) then
  584. begin
  585. for icond:=low(tasmcond) to high(tasmcond) do
  586. begin
  587. if copy(hs,2,3)=uppercond2str[icond] then
  588. begin
  589. actopcode:=A_BRxx;
  590. actasmtoken:=AS_OPCODE;
  591. actcondition:=icond;
  592. is_asmopcode:=true;
  593. exit;
  594. end;
  595. end;
  596. end;
  597. maxlen:=max(length(hs),5);
  598. actopcode:=A_NONE;
  599. for j:=maxlen downto 1 do
  600. begin
  601. actopcode:=tasmop(PtrUInt(iasmops.Find(copy(hs,1,j))));
  602. if actopcode<>A_NONE then
  603. begin
  604. actasmtoken:=AS_OPCODE;
  605. { strip op code }
  606. delete(hs,1,j);
  607. break;
  608. end;
  609. end;
  610. if actopcode=A_NONE then
  611. exit;
  612. { search for condition, conditions are always 2 chars }
  613. if length(hs)>1 then
  614. begin
  615. for icond:=low(tasmcond) to high(tasmcond) do
  616. begin
  617. if copy(hs,1,2)=uppercond2str[icond] then
  618. begin
  619. actcondition:=icond;
  620. { strip condition }
  621. delete(hs,1,2);
  622. break;
  623. end;
  624. end;
  625. end;
  626. { if we stripped all postfixes, it's a valid opcode }
  627. is_asmopcode:=length(hs)=0;
  628. end;
  629. procedure tavrattreader.ConvertCalljmp(instr : tavrinstruction);
  630. var
  631. newopr : toprrec;
  632. begin
  633. if instr.Operands[1].opr.typ=OPR_REFERENCE then
  634. begin
  635. newopr.typ:=OPR_SYMBOL;
  636. newopr.symbol:=instr.Operands[1].opr.ref.symbol;
  637. newopr.symofs:=instr.Operands[1].opr.ref.offset;
  638. if (instr.Operands[1].opr.ref.base<>NR_NO) or
  639. (instr.Operands[1].opr.ref.index<>NR_NO) then
  640. Message(asmr_e_syn_operand);
  641. instr.Operands[1].opr:=newopr;
  642. end;
  643. end;
  644. procedure tavrattreader.handleopcode;
  645. var
  646. instr : tavrinstruction;
  647. begin
  648. instr:=tavrinstruction.Create(tavroperand);
  649. BuildOpcode(instr);
  650. { if is_calljmp(instr.opcode) then
  651. ConvertCalljmp(instr); }
  652. {
  653. instr.AddReferenceSizes;
  654. instr.SetInstructionOpsize;
  655. instr.CheckOperandSizes;
  656. }
  657. instr.ConcatInstruction(curlist);
  658. instr.Free;
  659. end;
  660. {*****************************************************************************
  661. Initialize
  662. *****************************************************************************}
  663. const
  664. asmmode_avr_att_info : tasmmodeinfo =
  665. (
  666. id : asmmode_avr_gas;
  667. idtxt : 'GAS';
  668. casmreader : tavrattreader;
  669. );
  670. asmmode_avr_standard_info : tasmmodeinfo =
  671. (
  672. id : asmmode_standard;
  673. idtxt : 'STANDARD';
  674. casmreader : tavrattreader;
  675. );
  676. initialization
  677. RegisterAsmMode(asmmode_avr_att_info);
  678. RegisterAsmMode(asmmode_avr_standard_info);
  679. end.