racpugas.pas 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721
  1. {
  2. $Id$
  3. Copyright (c) 1998-2002 by Mazen NEIFER
  4. Does the parsing for the i386 GNU AS styled inline assembler.
  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 racpugas;
  19. {$i fpcdefs.inc}
  20. Interface
  21. uses
  22. raatt,racpu;
  23. type
  24. tSparcReader = class(tattreader)
  25. function is_asmopcode(const s: string):boolean;override;
  26. procedure handleopcode;override;
  27. procedure BuildReference(oper : tSparcoperand);
  28. procedure BuildOperand(oper : tSparcoperand);
  29. procedure BuildOpCode(instr : tSparcinstruction);
  30. procedure ReadAt(oper : tSparcoperand);
  31. procedure ReadSym(oper : tSparcoperand);
  32. procedure ConvertCalljmp(instr : tSparcinstruction);
  33. procedure handlepercent;override;
  34. end;
  35. Implementation
  36. uses
  37. { helpers }
  38. cutils,
  39. { global }
  40. globtype,globals,verbose,
  41. systems,
  42. { aasm }
  43. cpubase,cpuinfo,aasmbase,aasmtai,aasmcpu,
  44. { symtable }
  45. symconst,symbase,symtype,symsym,symtable,
  46. { parser }
  47. scanner,
  48. procinfo,
  49. itcpugas,
  50. rabase,rautils,
  51. cgbase,cgobj
  52. ;
  53. procedure tSparcReader.ReadSym(oper : tSparcoperand);
  54. var
  55. tempstr : string;
  56. typesize,l,k : longint;
  57. begin
  58. tempstr:=actasmpattern;
  59. Consume(AS_ID);
  60. { typecasting? }
  61. if (actasmtoken=AS_LPAREN) and
  62. SearchType(tempstr,typesize) then
  63. begin
  64. oper.hastype:=true;
  65. Consume(AS_LPAREN);
  66. BuildOperand(oper);
  67. Consume(AS_RPAREN);
  68. if oper.opr.typ in [OPR_REFERENCE,OPR_LOCAL] then
  69. oper.SetSize(typesize,true);
  70. end
  71. else
  72. if not oper.SetupVar(tempstr,false) then
  73. Message1(sym_e_unknown_id,tempstr);
  74. { record.field ? }
  75. if actasmtoken=AS_DOT then
  76. begin
  77. BuildRecordOffsetSize(tempstr,l,k);
  78. inc(oper.opr.ref.offset,l);
  79. end;
  80. end;
  81. procedure tSparcReader.ReadAt(oper : tSparcoperand);
  82. begin
  83. { check for ...@ }
  84. if actasmtoken=AS_AT then
  85. begin
  86. if (oper.opr.ref.symbol=nil) and
  87. (oper.opr.ref.offset = 0) then
  88. Message(asmr_e_invalid_reference_syntax);
  89. Consume(AS_AT);
  90. if actasmtoken=AS_ID then
  91. begin
  92. if upper(actasmpattern)='L' then
  93. oper.opr.ref.symaddr:=refs_lo
  94. else if upper(actasmpattern)='HA' then
  95. oper.opr.ref.symaddr:=refs_hi
  96. else
  97. Message(asmr_e_invalid_reference_syntax);
  98. Consume(AS_ID);
  99. end
  100. else
  101. Message(asmr_e_invalid_reference_syntax);
  102. end;
  103. end;
  104. Procedure tSparcReader.BuildReference(oper : tSparcoperand);
  105. procedure Consume_RParen;
  106. begin
  107. if actasmtoken <> AS_RPAREN then
  108. Begin
  109. Message(asmr_e_invalid_reference_syntax);
  110. RecoverConsume(true);
  111. end
  112. else
  113. begin
  114. Consume(AS_RPAREN);
  115. if not (actasmtoken in [AS_COMMA,AS_SEPARATOR,AS_END]) then
  116. Begin
  117. Message(asmr_e_invalid_reference_syntax);
  118. RecoverConsume(true);
  119. end;
  120. end;
  121. end;
  122. var
  123. l : longint;
  124. begin
  125. Consume(AS_LPAREN);
  126. Case actasmtoken of
  127. AS_INTNUM,
  128. AS_MINUS,
  129. AS_PLUS:
  130. Begin
  131. { offset(offset) is invalid }
  132. If oper.opr.Ref.Offset <> 0 Then
  133. Begin
  134. Message(asmr_e_invalid_reference_syntax);
  135. RecoverConsume(true);
  136. End
  137. Else
  138. Begin
  139. oper.opr.Ref.Offset:=BuildConstExpression(false,true);
  140. Consume(AS_RPAREN);
  141. if actasmtoken=AS_AT then
  142. ReadAt(oper);
  143. end;
  144. exit;
  145. End;
  146. AS_REGISTER: { (reg ... }
  147. Begin
  148. if ((oper.opr.typ=OPR_REFERENCE) and (oper.opr.ref.base<>NR_NO)) or
  149. ((oper.opr.typ=OPR_LOCAL) and (oper.opr.localsym.localloc.loc<>LOC_REGISTER)) then
  150. message(asmr_e_cannot_index_relative_var);
  151. oper.opr.ref.base:=actasmregister;
  152. Consume(AS_REGISTER);
  153. { can either be a register or a right parenthesis }
  154. { (reg) }
  155. if actasmtoken=AS_RPAREN then
  156. Begin
  157. Consume_RParen;
  158. exit;
  159. end;
  160. { (reg,reg .. }
  161. Consume(AS_COMMA);
  162. if (actasmtoken=AS_REGISTER) and
  163. (oper.opr.Ref.Offset = 0) then
  164. Begin
  165. oper.opr.ref.index:=actasmregister;
  166. Consume(AS_REGISTER);
  167. Consume_RParen;
  168. end
  169. else
  170. Begin
  171. Message(asmr_e_invalid_reference_syntax);
  172. RecoverConsume(false);
  173. end;
  174. end; {end case }
  175. AS_ID:
  176. Begin
  177. ReadSym(oper);
  178. { add a constant expression? }
  179. if (actasmtoken=AS_PLUS) then
  180. begin
  181. l:=BuildConstExpression(true,true);
  182. case oper.opr.typ of
  183. OPR_CONSTANT :
  184. inc(oper.opr.val,l);
  185. OPR_LOCAL :
  186. inc(oper.opr.localsymofs,l);
  187. OPR_REFERENCE :
  188. inc(oper.opr.ref.offset,l);
  189. else
  190. internalerror(200309202);
  191. end;
  192. end;
  193. Consume(AS_RPAREN);
  194. if actasmtoken=AS_AT then
  195. ReadAt(oper);
  196. End;
  197. AS_COMMA: { (, ... can either be scaling, or index }
  198. Begin
  199. Consume(AS_COMMA);
  200. { Index }
  201. if (actasmtoken=AS_REGISTER) then
  202. Begin
  203. oper.opr.ref.index:=actasmregister;
  204. Consume(AS_REGISTER);
  205. { check for scaling ... }
  206. Consume_RParen;
  207. end
  208. else
  209. begin
  210. Message(asmr_e_invalid_reference_syntax);
  211. RecoverConsume(false);
  212. end;
  213. end;
  214. else
  215. Begin
  216. Message(asmr_e_invalid_reference_syntax);
  217. RecoverConsume(false);
  218. end;
  219. end;
  220. end;
  221. procedure TSparcReader.handlepercent;
  222. var
  223. len : longint;
  224. begin
  225. len:=1;
  226. actasmpattern[len]:='%';
  227. c:=current_scanner.asmgetchar;
  228. { to be a register there must be a letter and not a number }
  229. if c in ['0'..'9'] then
  230. begin
  231. actasmtoken:=AS_MOD;
  232. end
  233. else
  234. begin
  235. while c in ['a'..'z','A'..'Z','0'..'9'] do
  236. Begin
  237. inc(len);
  238. actasmpattern[len]:=c;
  239. c:=current_scanner.asmgetchar;
  240. end;
  241. actasmpattern[0]:=chr(len);
  242. uppervar(actasmpattern);
  243. if (actasmpattern = '%ST') and (c='(') then
  244. Begin
  245. actasmpattern:=actasmpattern+c;
  246. c:=current_scanner.asmgetchar;
  247. if c in ['0'..'9'] then
  248. actasmpattern:=actasmpattern + c
  249. else
  250. Message(asmr_e_invalid_fpu_register);
  251. c:=current_scanner.asmgetchar;
  252. if c <> ')' then
  253. Message(asmr_e_invalid_fpu_register)
  254. else
  255. Begin
  256. actasmpattern:=actasmpattern + c;
  257. c:=current_scanner.asmgetchar; { let us point to next character. }
  258. end;
  259. end;
  260. if is_register(actasmpattern) then
  261. exit;
  262. Message(asmr_e_invalid_register);
  263. actasmtoken:=raatt.AS_NONE;
  264. end;
  265. end;
  266. Procedure tSparcReader.BuildOperand(oper : tSparcoperand);
  267. var
  268. expr : string;
  269. typesize,l : longint;
  270. procedure AddLabelOperand(hl:tasmlabel);
  271. begin
  272. if not(actasmtoken in [AS_PLUS,AS_MINUS,AS_LPAREN]) and
  273. is_calljmp(actopcode) then
  274. begin
  275. oper.opr.typ:=OPR_SYMBOL;
  276. oper.opr.symbol:=hl;
  277. end
  278. else
  279. begin
  280. oper.InitRef;
  281. oper.opr.ref.symbol:=hl;
  282. end;
  283. end;
  284. procedure MaybeRecordOffset;
  285. var
  286. hasdot : boolean;
  287. l,
  288. toffset,
  289. tsize : longint;
  290. begin
  291. if not(actasmtoken in [AS_DOT,AS_PLUS,AS_MINUS]) then
  292. exit;
  293. l:=0;
  294. hasdot:=(actasmtoken=AS_DOT);
  295. if hasdot then
  296. begin
  297. if expr<>'' then
  298. begin
  299. BuildRecordOffsetSize(expr,toffset,tsize);
  300. inc(l,toffset);
  301. oper.SetSize(tsize,true);
  302. end;
  303. end;
  304. if actasmtoken in [AS_PLUS,AS_MINUS] then
  305. inc(l,BuildConstExpression(true,false));
  306. case oper.opr.typ of
  307. OPR_LOCAL :
  308. begin
  309. { don't allow direct access to fields of parameters, because that
  310. will generate buggy code. Allow it only for explicit typecasting }
  311. if hasdot and
  312. (not oper.hastype) and
  313. (tvarsym(oper.opr.localsym).owner.symtabletype=parasymtable) and
  314. (current_procinfo.procdef.proccalloption<>pocall_register) then
  315. Message(asmr_e_cannot_access_field_directly_for_parameters);
  316. inc(oper.opr.localsymofs,l)
  317. end;
  318. OPR_CONSTANT :
  319. inc(oper.opr.val,l);
  320. OPR_REFERENCE :
  321. inc(oper.opr.ref.offset,l);
  322. else
  323. internalerror(200309221);
  324. end;
  325. end;
  326. function MaybeBuildReference:boolean;
  327. { Try to create a reference, if not a reference is found then false
  328. is returned }
  329. begin
  330. MaybeBuildReference:=true;
  331. case actasmtoken of
  332. AS_INTNUM,
  333. AS_MINUS,
  334. AS_PLUS:
  335. Begin
  336. oper.opr.ref.offset:=BuildConstExpression(True,False);
  337. if actasmtoken<>AS_LPAREN then
  338. Message(asmr_e_invalid_reference_syntax)
  339. else
  340. BuildReference(oper);
  341. end;
  342. AS_LPAREN:
  343. BuildReference(oper);
  344. AS_ID: { only a variable is allowed ... }
  345. Begin
  346. ReadSym(oper);
  347. case actasmtoken of
  348. AS_END,
  349. AS_SEPARATOR,
  350. AS_COMMA: ;
  351. AS_LPAREN:
  352. BuildReference(oper);
  353. else
  354. Begin
  355. Message(asmr_e_invalid_reference_syntax);
  356. Consume(actasmtoken);
  357. end;
  358. end; {end case }
  359. end;
  360. else
  361. MaybeBuildReference:=false;
  362. end; { end case }
  363. end;
  364. var
  365. tempreg : tregister;
  366. hl : tasmlabel;
  367. ofs : longint;
  368. Begin
  369. expr:='';
  370. case actasmtoken of
  371. AS_LPAREN: { Memory reference or constant expression }
  372. Begin
  373. oper.InitRef;
  374. BuildReference(oper);
  375. end;
  376. AS_INTNUM,
  377. AS_MINUS,
  378. AS_PLUS:
  379. Begin
  380. { Constant memory offset }
  381. { This must absolutely be followed by ( }
  382. oper.InitRef;
  383. oper.opr.ref.offset:=BuildConstExpression(True,False);
  384. if actasmtoken<>AS_LPAREN then
  385. begin
  386. ofs:=oper.opr.ref.offset;
  387. BuildConstantOperand(oper);
  388. inc(oper.opr.val,ofs);
  389. end
  390. else
  391. BuildReference(oper);
  392. end;
  393. AS_ID: { A constant expression, or a Variable ref. }
  394. Begin
  395. { Local Label ? }
  396. if is_locallabel(actasmpattern) then
  397. begin
  398. CreateLocalLabel(actasmpattern,hl,false);
  399. Consume(AS_ID);
  400. AddLabelOperand(hl);
  401. end
  402. else
  403. { Check for label }
  404. if SearchLabel(actasmpattern,hl,false) then
  405. begin
  406. Consume(AS_ID);
  407. AddLabelOperand(hl);
  408. end
  409. else
  410. { probably a variable or normal expression }
  411. { or a procedure (such as in CALL ID) }
  412. Begin
  413. { is it a constant ? }
  414. if SearchIConstant(actasmpattern,l) then
  415. Begin
  416. if not (oper.opr.typ in [OPR_NONE,OPR_CONSTANT]) then
  417. Message(asmr_e_invalid_operand_type);
  418. BuildConstantOperand(oper);
  419. end
  420. else
  421. begin
  422. expr:=actasmpattern;
  423. Consume(AS_ID);
  424. { typecasting? }
  425. if (actasmtoken=AS_LPAREN) and
  426. SearchType(expr,typesize) then
  427. begin
  428. oper.hastype:=true;
  429. Consume(AS_LPAREN);
  430. BuildOperand(oper);
  431. Consume(AS_RPAREN);
  432. if oper.opr.typ in [OPR_REFERENCE,OPR_LOCAL] then
  433. oper.SetSize(typesize,true);
  434. end
  435. else
  436. begin
  437. if oper.SetupVar(expr,false) then
  438. ReadAt(oper)
  439. else
  440. Begin
  441. { look for special symbols ... }
  442. if expr= '__HIGH' then
  443. begin
  444. consume(AS_LPAREN);
  445. if not oper.setupvar('high'+actasmpattern,false) then
  446. Message1(sym_e_unknown_id,'high'+actasmpattern);
  447. consume(AS_ID);
  448. consume(AS_RPAREN);
  449. end
  450. else
  451. if expr = '__RESULT' then
  452. oper.SetUpResult
  453. else
  454. if expr = '__SELF' then
  455. oper.SetupSelf
  456. else
  457. if expr = '__OLDEBP' then
  458. oper.SetupOldEBP
  459. else
  460. { check for direct symbolic names }
  461. { only if compiling the system unit }
  462. if (cs_compilesystem in aktmoduleswitches) then
  463. begin
  464. if not oper.SetupDirectVar(expr) then
  465. Begin
  466. { not found, finally ... add it anyways ... }
  467. Message1(asmr_w_id_supposed_external,expr);
  468. oper.InitRef;
  469. oper.opr.ref.symbol:=objectlibrary.newasmsymbol(expr);
  470. end;
  471. end
  472. else
  473. Message1(sym_e_unknown_id,expr);
  474. end;
  475. end;
  476. end;
  477. if actasmtoken=AS_DOT then
  478. MaybeRecordOffset;
  479. { add a constant expression? }
  480. if (actasmtoken=AS_PLUS) then
  481. begin
  482. l:=BuildConstExpression(true,false);
  483. case oper.opr.typ of
  484. OPR_CONSTANT :
  485. inc(oper.opr.val,l);
  486. OPR_LOCAL :
  487. inc(oper.opr.localsymofs,l);
  488. OPR_REFERENCE :
  489. inc(oper.opr.ref.offset,l);
  490. else
  491. internalerror(200309202);
  492. end;
  493. end
  494. end;
  495. { Do we have a indexing reference, then parse it also }
  496. if actasmtoken=AS_LPAREN then
  497. BuildReference(oper);
  498. end;
  499. AS_REGISTER: { Register, a variable reference or a constant reference }
  500. Begin
  501. { save the type of register used. }
  502. tempreg:=actasmregister;
  503. Consume(AS_REGISTER);
  504. if (actasmtoken in [AS_END,AS_SEPARATOR,AS_COMMA]) then
  505. begin
  506. if not (oper.opr.typ in [OPR_NONE,OPR_REGISTER]) then
  507. Message(asmr_e_invalid_operand_type);
  508. oper.opr.typ:=OPR_REGISTER;
  509. oper.opr.reg:=tempreg;
  510. end
  511. else
  512. Message(asmr_e_syn_operand);
  513. end;
  514. AS_END,
  515. AS_SEPARATOR,
  516. AS_COMMA: ;
  517. else
  518. Begin
  519. Message(asmr_e_syn_operand);
  520. Consume(actasmtoken);
  521. end;
  522. end; { end case }
  523. end;
  524. {*****************************************************************************
  525. tSparcReader
  526. *****************************************************************************}
  527. procedure tSparcReader.BuildOpCode(instr : tSparcinstruction);
  528. var
  529. operandnum : longint;
  530. Begin
  531. { opcode }
  532. if (actasmtoken<>AS_OPCODE) then
  533. Begin
  534. Message(asmr_e_invalid_or_missing_opcode);
  535. RecoverConsume(true);
  536. exit;
  537. end;
  538. { Fill the instr object with the current state }
  539. with instr do
  540. begin
  541. Opcode:=ActOpcode;
  542. condition:=ActCondition;
  543. end;
  544. { We are reading operands, so opcode will be an AS_ID }
  545. operandnum:=1;
  546. Consume(AS_OPCODE);
  547. { Zero operand opcode ? }
  548. if actasmtoken in [AS_SEPARATOR,AS_END] then
  549. begin
  550. operandnum:=0;
  551. exit;
  552. end;
  553. { Read the operands }
  554. repeat
  555. case actasmtoken of
  556. AS_COMMA: { Operand delimiter }
  557. Begin
  558. if operandnum>Max_Operands then
  559. Message(asmr_e_too_many_operands)
  560. else
  561. begin
  562. { condition operands doesn't set the operand but write to the
  563. condition field of the instruction
  564. }
  565. if instr.Operands[operandnum].opr.typ<>OPR_NONE then
  566. Inc(operandnum);
  567. end;
  568. Consume(AS_COMMA);
  569. end;
  570. AS_SEPARATOR,
  571. AS_END : { End of asm operands for this opcode }
  572. begin
  573. break;
  574. end;
  575. else
  576. BuildOperand(instr.Operands[operandnum] as tSparcoperand);
  577. end; { end case }
  578. until false;
  579. if (operandnum=1) and (instr.Operands[operandnum].opr.typ=OPR_NONE) then
  580. dec(operandnum);
  581. instr.Ops:=operandnum;
  582. end;
  583. function TSparcReader.is_asmopcode(const s: string):boolean;
  584. var
  585. str2opEntry: tstr2opEntry;
  586. cond:TAsmCond;
  587. Begin
  588. { making s a value parameter would break other assembler readers }
  589. is_asmopcode:=false;
  590. { clear op code }
  591. actopcode:=A_None;
  592. { clear condition }
  593. fillchar(actcondition,sizeof(actcondition),0);
  594. str2opentry:=tstr2opentry(iasmops.search(s));
  595. if assigned(str2opentry) then
  596. begin
  597. actopcode:=str2opentry.op;
  598. actasmtoken:=AS_OPCODE;
  599. is_asmopcode:=true;
  600. end
  601. { not found, check branch instructions }
  602. else if Upcase(s[1])='B' then
  603. begin
  604. { we can search here without an extra table which is sorted by string length
  605. because we take the whole remaining string without the leading B }
  606. actopcode := A_Bxx;
  607. for cond:=low(TAsmCond) to high(TAsmCond) do
  608. if(cond in [C_AE])and(Upper(copy(s,2,length(s)-1))=Upper(Cond2Str[cond])) then
  609. begin
  610. WriteLn('Bxx');
  611. actasmtoken:=AS_OPCODE;
  612. is_asmopcode:=true;
  613. end;
  614. end;
  615. end;
  616. procedure tSparcReader.ConvertCalljmp(instr : tSparcinstruction);
  617. var
  618. newopr : toprrec;
  619. begin
  620. if instr.Operands[1].opr.typ=OPR_REFERENCE then
  621. with newopr do
  622. begin
  623. typ:=OPR_SYMBOL;
  624. symbol:=instr.Operands[1].opr.ref.symbol;
  625. symofs:=instr.Operands[1].opr.ref.offset;
  626. if (instr.Operands[1].opr.ref.base<>NR_NO) or
  627. (instr.Operands[1].opr.ref.index<>NR_NO) or
  628. (instr.Operands[1].opr.ref.symaddr<>refs_full) then
  629. Message(asmr_e_syn_operand);
  630. instr.Operands[1].opr:=newopr;
  631. end;
  632. end;
  633. procedure tSparcReader.handleopcode;
  634. var
  635. instr : tSparcinstruction;
  636. begin
  637. instr:=TSparcInstruction.Create(TSparcOperand);
  638. BuildOpcode(instr);
  639. with instr do
  640. begin
  641. condition := actcondition;
  642. if is_calljmp(opcode) then
  643. ConvertCalljmp(instr);
  644. ConcatInstruction(curlist);
  645. Free;
  646. end;
  647. end;
  648. {*****************************************************************************
  649. Initialize
  650. *****************************************************************************}
  651. const
  652. asmmode_Sparc_att_info : tasmmodeinfo =
  653. (
  654. id : asmmode_Sparc_gas;
  655. idtxt : 'GAS';
  656. casmreader : tSparcReader;
  657. );
  658. asmmode_Sparc_standard_info : tasmmodeinfo =
  659. (
  660. id : asmmode_standard;
  661. idtxt : 'DIRECT';
  662. casmreader : tSparcReader;
  663. );
  664. initialization
  665. RegisterAsmMode(asmmode_Sparc_att_info);
  666. RegisterAsmMode(asmmode_Sparc_standard_info);
  667. end.
  668. {
  669. $Log$
  670. Revision 1.1 2003-12-08 13:02:21 mazen
  671. + support for native sparc assembler reader
  672. }