a.y 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974
  1. %{
  2. #include "a.h"
  3. %}
  4. %union
  5. {
  6. Sym *sym;
  7. long lval;
  8. double dval;
  9. char sval[8];
  10. Gen gen;
  11. }
  12. %left '|'
  13. %left '^'
  14. %left '&'
  15. %left '<' '>'
  16. %left '+' '-'
  17. %left '*' '/' '%'
  18. %token <lval> LMOVW LMOVB LABS LLOGW LSHW LADDW LCMP LCROP
  19. %token <lval> LBRA LFMOV LFCONV LFCMP LFADD LFMA LTRAP LXORW
  20. %token <lval> LNOP LEND LRETT LWORD LTEXT LDATA LRETRN
  21. %token <lval> LCONST LSP LSB LFP LPC LCREG LFLUSH
  22. %token <lval> LREG LFREG LR LCR LF LFPSCR
  23. %token <lval> LLR LCTR LSPR LSPREG LSEG LMSR
  24. %token <lval> LSCHED LXLD LXST LXOP LXMV
  25. %token <lval> LRLWM LMOVMW LMOVEM LMOVFL LMTFSB LMA
  26. %token <dval> LFCONST
  27. %token <sval> LSCONST
  28. %token <sym> LNAME LLAB LVAR
  29. %type <lval> con expr pointer offset sreg
  30. %type <gen> addr rreg regaddr name creg freg xlreg lr ctr
  31. %type <gen> imm ximm fimm rel psr lcr cbit fpscr fpscrf seg msr mask
  32. %%
  33. prog:
  34. | prog line
  35. line:
  36. LLAB ':'
  37. {
  38. if($1->value != pc)
  39. yyerror("redeclaration of %s", $1->name);
  40. $1->value = pc;
  41. }
  42. line
  43. | LNAME ':'
  44. {
  45. $1->type = LLAB;
  46. $1->value = pc;
  47. }
  48. line
  49. | LNAME '=' expr ';'
  50. {
  51. $1->type = LVAR;
  52. $1->value = $3;
  53. }
  54. | LVAR '=' expr ';'
  55. {
  56. if($1->value != $3)
  57. yyerror("redeclaration of %s", $1->name);
  58. $1->value = $3;
  59. }
  60. | LSCHED ';'
  61. {
  62. nosched = $1;
  63. }
  64. | ';'
  65. | inst ';'
  66. | error ';'
  67. inst:
  68. /*
  69. * load ints and bytes
  70. */
  71. LMOVW rreg ',' rreg
  72. {
  73. outcode($1, &$2, NREG, &$4);
  74. }
  75. | LMOVW addr ',' rreg
  76. {
  77. outcode($1, &$2, NREG, &$4);
  78. }
  79. | LMOVW regaddr ',' rreg
  80. {
  81. outcode($1, &$2, NREG, &$4);
  82. }
  83. | LMOVB rreg ',' rreg
  84. {
  85. outcode($1, &$2, NREG, &$4);
  86. }
  87. | LMOVB addr ',' rreg
  88. {
  89. outcode($1, &$2, NREG, &$4);
  90. }
  91. | LMOVB regaddr ',' rreg
  92. {
  93. outcode($1, &$2, NREG, &$4);
  94. }
  95. /*
  96. * load floats
  97. */
  98. | LFMOV addr ',' freg
  99. {
  100. outcode($1, &$2, NREG, &$4);
  101. }
  102. | LFMOV regaddr ',' freg
  103. {
  104. outcode($1, &$2, NREG, &$4);
  105. }
  106. | LFMOV fimm ',' freg
  107. {
  108. outcode($1, &$2, NREG, &$4);
  109. }
  110. | LFMOV freg ',' freg
  111. {
  112. outcode($1, &$2, NREG, &$4);
  113. }
  114. | LFMOV freg ',' addr
  115. {
  116. outcode($1, &$2, NREG, &$4);
  117. }
  118. | LFMOV freg ',' regaddr
  119. {
  120. outcode($1, &$2, NREG, &$4);
  121. }
  122. /*
  123. * store ints and bytes
  124. */
  125. | LMOVW rreg ',' addr
  126. {
  127. outcode($1, &$2, NREG, &$4);
  128. }
  129. | LMOVW rreg ',' regaddr
  130. {
  131. outcode($1, &$2, NREG, &$4);
  132. }
  133. | LMOVB rreg ',' addr
  134. {
  135. outcode($1, &$2, NREG, &$4);
  136. }
  137. | LMOVB rreg ',' regaddr
  138. {
  139. outcode($1, &$2, NREG, &$4);
  140. }
  141. /*
  142. * store floats
  143. */
  144. | LMOVW freg ',' addr
  145. {
  146. outcode($1, &$2, NREG, &$4);
  147. }
  148. | LMOVW freg ',' regaddr
  149. {
  150. outcode($1, &$2, NREG, &$4);
  151. }
  152. /*
  153. * floating point status
  154. */
  155. | LMOVW fpscr ',' freg
  156. {
  157. outcode($1, &$2, NREG, &$4);
  158. }
  159. | LMOVW freg ',' fpscr
  160. {
  161. outcode($1, &$2, NREG, &$4);
  162. }
  163. | LMOVW freg ',' imm ',' fpscr
  164. {
  165. outgcode($1, &$2, NREG, &$4, &$6);
  166. }
  167. | LMOVW fpscr ',' creg
  168. {
  169. outcode($1, &$2, NREG, &$4);
  170. }
  171. | LMOVW imm ',' fpscrf
  172. {
  173. outcode($1, &$2, NREG, &$4);
  174. }
  175. | LMTFSB imm ',' con
  176. {
  177. outcode($1, &$2, $4, &nullgen);
  178. }
  179. /*
  180. * field moves (mtcrf)
  181. */
  182. | LMOVW rreg ',' imm ',' lcr
  183. {
  184. outgcode($1, &$2, NREG, &$4, &$6);
  185. }
  186. | LMOVW rreg ',' creg
  187. {
  188. outcode($1, &$2, NREG, &$4);
  189. }
  190. | LMOVW rreg ',' lcr
  191. {
  192. outcode($1, &$2, NREG, &$4);
  193. }
  194. /*
  195. * integer operations
  196. * logical instructions
  197. * shift instructions
  198. * unary instructions
  199. */
  200. | LADDW rreg ',' sreg ',' rreg
  201. {
  202. outcode($1, &$2, $4, &$6);
  203. }
  204. | LADDW imm ',' sreg ',' rreg
  205. {
  206. outcode($1, &$2, $4, &$6);
  207. }
  208. | LADDW rreg ',' imm ',' rreg
  209. {
  210. outgcode($1, &$2, NREG, &$4, &$6);
  211. }
  212. | LADDW rreg ',' rreg
  213. {
  214. outcode($1, &$2, NREG, &$4);
  215. }
  216. | LADDW imm ',' rreg
  217. {
  218. outcode($1, &$2, NREG, &$4);
  219. }
  220. | LLOGW rreg ',' sreg ',' rreg
  221. {
  222. outcode($1, &$2, $4, &$6);
  223. }
  224. | LLOGW rreg ',' rreg
  225. {
  226. outcode($1, &$2, NREG, &$4);
  227. }
  228. | LSHW rreg ',' sreg ',' rreg
  229. {
  230. outcode($1, &$2, $4, &$6);
  231. }
  232. | LSHW rreg ',' rreg
  233. {
  234. outcode($1, &$2, NREG, &$4);
  235. }
  236. | LSHW imm ',' sreg ',' rreg
  237. {
  238. outcode($1, &$2, $4, &$6);
  239. }
  240. | LSHW imm ',' rreg
  241. {
  242. outcode($1, &$2, NREG, &$4);
  243. }
  244. | LABS rreg ',' rreg
  245. {
  246. outcode($1, &$2, NREG, &$4);
  247. }
  248. | LABS rreg
  249. {
  250. outcode($1, &$2, NREG, &$2);
  251. }
  252. /*
  253. * multiply-accumulate
  254. */
  255. | LMA rreg ',' sreg ',' rreg
  256. {
  257. outcode($1, &$2, $4, &$6);
  258. }
  259. /*
  260. * move immediate: macro for cau+or, addi, addis, and other combinations
  261. */
  262. | LMOVW imm ',' rreg
  263. {
  264. outcode($1, &$2, NREG, &$4);
  265. }
  266. | LMOVW ximm ',' rreg
  267. {
  268. outcode($1, &$2, NREG, &$4);
  269. }
  270. /*
  271. * condition register operations
  272. */
  273. | LCROP cbit ',' cbit
  274. {
  275. outcode($1, &$2, $4.reg, &$4);
  276. }
  277. | LCROP cbit ',' con ',' cbit
  278. {
  279. outcode($1, &$2, $4, &$6);
  280. }
  281. /*
  282. * condition register moves
  283. * move from machine state register
  284. */
  285. | LMOVW creg ',' creg
  286. {
  287. outcode($1, &$2, NREG, &$4);
  288. }
  289. | LMOVW psr ',' creg
  290. {
  291. outcode($1, &$2, NREG, &$4);
  292. }
  293. | LMOVW lcr ',' rreg
  294. {
  295. outcode($1, &$2, NREG, &$4);
  296. }
  297. | LMOVW psr ',' rreg
  298. {
  299. outcode($1, &$2, NREG, &$4);
  300. }
  301. | LMOVW seg ',' rreg
  302. {
  303. int r;
  304. r = $2.offset;
  305. $2.offset = 0;
  306. outcode($1, &$2, r, &$4);
  307. }
  308. | LMOVW rreg ',' seg
  309. {
  310. int r;
  311. r = $4.offset;
  312. $4.offset = 0;
  313. outcode($1, &$2, r, &$4);
  314. }
  315. | LMOVW xlreg ',' rreg
  316. {
  317. outcode($1, &$2, NREG, &$4);
  318. }
  319. | LMOVW rreg ',' xlreg
  320. {
  321. outcode($1, &$2, NREG, &$4);
  322. }
  323. | LMOVW creg ',' psr
  324. {
  325. outcode($1, &$2, NREG, &$4);
  326. }
  327. | LMOVW rreg ',' psr
  328. {
  329. outcode($1, &$2, NREG, &$4);
  330. }
  331. /*
  332. * branch, branch conditional
  333. * branch conditional register
  334. * branch conditional to count register
  335. */
  336. | LBRA rel
  337. {
  338. outcode($1, &nullgen, NREG, &$2);
  339. }
  340. | LBRA addr
  341. {
  342. outcode($1, &nullgen, NREG, &$2);
  343. }
  344. | LBRA '(' xlreg ')'
  345. {
  346. outcode($1, &nullgen, NREG, &$3);
  347. }
  348. | LBRA ',' rel
  349. {
  350. outcode($1, &nullgen, NREG, &$3);
  351. }
  352. | LBRA ',' addr
  353. {
  354. outcode($1, &nullgen, NREG, &$3);
  355. }
  356. | LBRA ',' '(' xlreg ')'
  357. {
  358. outcode($1, &nullgen, NREG, &$4);
  359. }
  360. | LBRA creg ',' rel
  361. {
  362. outcode($1, &$2, NREG, &$4);
  363. }
  364. | LBRA creg ',' addr
  365. {
  366. outcode($1, &$2, NREG, &$4);
  367. }
  368. | LBRA creg ',' '(' xlreg ')'
  369. {
  370. outcode($1, &$2, NREG, &$5);
  371. }
  372. | LBRA con ',' rel
  373. {
  374. outcode($1, &nullgen, $2, &$4);
  375. }
  376. | LBRA con ',' addr
  377. {
  378. outcode($1, &nullgen, $2, &$4);
  379. }
  380. | LBRA con ',' '(' xlreg ')'
  381. {
  382. outcode($1, &nullgen, $2, &$5);
  383. }
  384. | LBRA con ',' con ',' rel
  385. {
  386. Gen g;
  387. g = nullgen;
  388. g.type = D_CONST;
  389. g.offset = $2;
  390. outcode($1, &g, $4, &$6);
  391. }
  392. | LBRA con ',' con ',' addr
  393. {
  394. Gen g;
  395. g = nullgen;
  396. g.type = D_CONST;
  397. g.offset = $2;
  398. outcode($1, &g, $4, &$6);
  399. }
  400. | LBRA con ',' con ',' '(' xlreg ')'
  401. {
  402. Gen g;
  403. g = nullgen;
  404. g.type = D_CONST;
  405. g.offset = $2;
  406. outcode($1, &g, $4, &$7);
  407. }
  408. /*
  409. * conditional trap
  410. */
  411. | LTRAP rreg ',' sreg
  412. {
  413. outcode($1, &$2, $4, &nullgen);
  414. }
  415. | LTRAP imm ',' sreg
  416. {
  417. outcode($1, &$2, $4, &nullgen);
  418. }
  419. | LTRAP rreg comma
  420. {
  421. outcode($1, &$2, NREG, &nullgen);
  422. }
  423. | LTRAP comma
  424. {
  425. outcode($1, &nullgen, NREG, &nullgen);
  426. }
  427. /*
  428. * floating point operate
  429. */
  430. | LFCONV freg ',' freg
  431. {
  432. outcode($1, &$2, NREG, &$4);
  433. }
  434. | LFADD freg ',' freg
  435. {
  436. outcode($1, &$2, NREG, &$4);
  437. }
  438. | LFADD freg ',' freg ',' freg
  439. {
  440. outcode($1, &$2, $4.reg, &$6);
  441. }
  442. | LFMA freg ',' freg ',' freg ',' freg
  443. {
  444. outgcode($1, &$2, $4.reg, &$6, &$8);
  445. }
  446. | LFCMP freg ',' freg
  447. {
  448. outcode($1, &$2, NREG, &$4);
  449. }
  450. | LFCMP freg ',' freg ',' creg
  451. {
  452. outcode($1, &$2, $6.reg, &$4);
  453. }
  454. /*
  455. * CMP
  456. */
  457. | LCMP rreg ',' rreg
  458. {
  459. outcode($1, &$2, NREG, &$4);
  460. }
  461. | LCMP rreg ',' imm
  462. {
  463. outcode($1, &$2, NREG, &$4);
  464. }
  465. | LCMP rreg ',' rreg ',' creg
  466. {
  467. outcode($1, &$2, $6.reg, &$4);
  468. }
  469. | LCMP rreg ',' imm ',' creg
  470. {
  471. outcode($1, &$2, $6.reg, &$4);
  472. }
  473. /*
  474. * rotate and mask
  475. */
  476. | LRLWM imm ',' rreg ',' imm ',' rreg
  477. {
  478. outgcode($1, &$2, $4.reg, &$6, &$8);
  479. }
  480. | LRLWM imm ',' rreg ',' mask ',' rreg
  481. {
  482. outgcode($1, &$2, $4.reg, &$6, &$8);
  483. }
  484. | LRLWM rreg ',' rreg ',' imm ',' rreg
  485. {
  486. outgcode($1, &$2, $4.reg, &$6, &$8);
  487. }
  488. | LRLWM rreg ',' rreg ',' mask ',' rreg
  489. {
  490. outgcode($1, &$2, $4.reg, &$6, &$8);
  491. }
  492. /*
  493. * load/store multiple
  494. */
  495. | LMOVMW addr ',' rreg
  496. {
  497. outcode($1, &$2, NREG, &$4);
  498. }
  499. | LMOVMW rreg ',' addr
  500. {
  501. outcode($1, &$2, NREG, &$4);
  502. }
  503. /*
  504. * various indexed load/store
  505. * indexed unary (eg, cache clear)
  506. */
  507. | LXLD regaddr ',' rreg
  508. {
  509. outcode($1, &$2, NREG, &$4);
  510. }
  511. | LXLD regaddr ',' imm ',' rreg
  512. {
  513. outgcode($1, &$2, NREG, &$4, &$6);
  514. }
  515. | LXST rreg ',' regaddr
  516. {
  517. outcode($1, &$2, NREG, &$4);
  518. }
  519. | LXST rreg ',' imm ',' regaddr
  520. {
  521. outgcode($1, &$2, NREG, &$4, &$6);
  522. }
  523. | LXMV regaddr ',' rreg
  524. {
  525. outcode($1, &$2, NREG, &$4);
  526. }
  527. | LXMV rreg ',' regaddr
  528. {
  529. outcode($1, &$2, NREG, &$4);
  530. }
  531. | LXOP regaddr
  532. {
  533. outcode($1, &$2, NREG, &nullgen);
  534. }
  535. /*
  536. * NOP
  537. */
  538. | LNOP comma
  539. {
  540. outcode($1, &nullgen, NREG, &nullgen);
  541. }
  542. | LNOP rreg comma
  543. {
  544. outcode($1, &$2, NREG, &nullgen);
  545. }
  546. | LNOP freg comma
  547. {
  548. outcode($1, &$2, NREG, &nullgen);
  549. }
  550. | LNOP ',' rreg
  551. {
  552. outcode($1, &nullgen, NREG, &$3);
  553. }
  554. | LNOP ',' freg
  555. {
  556. outcode($1, &nullgen, NREG, &$3);
  557. }
  558. /*
  559. * word
  560. */
  561. | LWORD imm comma
  562. {
  563. outcode($1, &$2, NREG, &nullgen);
  564. }
  565. | LWORD ximm comma
  566. {
  567. outcode($1, &$2, NREG, &nullgen);
  568. }
  569. /*
  570. * END
  571. */
  572. | LEND comma
  573. {
  574. outcode($1, &nullgen, NREG, &nullgen);
  575. }
  576. /*
  577. * TEXT/GLOBL
  578. */
  579. | LTEXT name ',' imm
  580. {
  581. outcode($1, &$2, NREG, &$4);
  582. }
  583. | LTEXT name ',' con ',' imm
  584. {
  585. outcode($1, &$2, $4, &$6);
  586. }
  587. | LTEXT name ',' imm ':' imm
  588. {
  589. outgcode($1, &$2, NREG, &$6, &$4);
  590. }
  591. | LTEXT name ',' con ',' imm ':' imm
  592. {
  593. outgcode($1, &$2, $4, &$8, &$6);
  594. }
  595. /*
  596. * DATA
  597. */
  598. | LDATA name '/' con ',' imm
  599. {
  600. outcode($1, &$2, $4, &$6);
  601. }
  602. | LDATA name '/' con ',' ximm
  603. {
  604. outcode($1, &$2, $4, &$6);
  605. }
  606. | LDATA name '/' con ',' fimm
  607. {
  608. outcode($1, &$2, $4, &$6);
  609. }
  610. /*
  611. * RETURN
  612. */
  613. | LRETRN comma
  614. {
  615. outcode($1, &nullgen, NREG, &nullgen);
  616. }
  617. rel:
  618. con '(' LPC ')'
  619. {
  620. $$ = nullgen;
  621. $$.type = D_BRANCH;
  622. $$.offset = $1 + pc;
  623. }
  624. | LNAME offset
  625. {
  626. $$ = nullgen;
  627. if(pass == 2)
  628. yyerror("undefined label: %s", $1->name);
  629. $$.type = D_BRANCH;
  630. $$.sym = $1;
  631. $$.offset = $2;
  632. }
  633. | LLAB offset
  634. {
  635. $$ = nullgen;
  636. $$.type = D_BRANCH;
  637. $$.sym = $1;
  638. $$.offset = $1->value + $2;
  639. }
  640. rreg:
  641. sreg
  642. {
  643. $$ = nullgen;
  644. $$.type = D_REG;
  645. $$.reg = $1;
  646. }
  647. xlreg:
  648. lr
  649. | ctr
  650. lr:
  651. LLR
  652. {
  653. $$ = nullgen;
  654. $$.type = D_SPR;
  655. $$.offset = $1;
  656. }
  657. lcr:
  658. LCR
  659. {
  660. $$ = nullgen;
  661. $$.type = D_CREG;
  662. $$.reg = NREG; /* whole register */
  663. }
  664. ctr:
  665. LCTR
  666. {
  667. $$ = nullgen;
  668. $$.type = D_SPR;
  669. $$.offset = $1;
  670. }
  671. msr:
  672. LMSR
  673. {
  674. $$ = nullgen;
  675. $$.type = D_MSR;
  676. }
  677. psr:
  678. LSPREG
  679. {
  680. $$ = nullgen;
  681. $$.type = D_SPR;
  682. $$.offset = $1;
  683. }
  684. | LSPR '(' con ')'
  685. {
  686. $$ = nullgen;
  687. $$.type = $1;
  688. $$.offset = $3;
  689. }
  690. | msr
  691. seg:
  692. LSEG '(' con ')'
  693. {
  694. if($3 < 0 || $3 > 15)
  695. yyerror("segment register number out of range");
  696. $$ = nullgen;
  697. $$.type = D_SREG;
  698. $$.reg = $3;
  699. $$.offset = NREG;
  700. }
  701. | LSEG '(' sreg ')'
  702. {
  703. $$ = nullgen;
  704. $$.type = D_SREG;
  705. $$.reg = NREG;
  706. $$.offset = $3;
  707. }
  708. fpscr:
  709. LFPSCR
  710. {
  711. $$ = nullgen;
  712. $$.type = D_FPSCR;
  713. $$.reg = NREG;
  714. }
  715. fpscrf:
  716. LFPSCR '(' con ')'
  717. {
  718. $$ = nullgen;
  719. $$.type = D_FPSCR;
  720. $$.reg = $3;
  721. }
  722. freg:
  723. LFREG
  724. {
  725. $$ = nullgen;
  726. $$.type = D_FREG;
  727. $$.reg = $1;
  728. }
  729. | LF '(' con ')'
  730. {
  731. $$ = nullgen;
  732. $$.type = D_FREG;
  733. $$.reg = $3;
  734. }
  735. creg:
  736. LCREG
  737. {
  738. $$ = nullgen;
  739. $$.type = D_CREG;
  740. $$.reg = $1;
  741. }
  742. | LCR '(' con ')'
  743. {
  744. $$ = nullgen;
  745. $$.type = D_CREG;
  746. $$.reg = $3;
  747. }
  748. cbit: con
  749. {
  750. $$ = nullgen;
  751. $$.type = D_REG;
  752. $$.reg = $1;
  753. }
  754. mask:
  755. con ',' con
  756. {
  757. int mb, me;
  758. ulong v;
  759. $$ = nullgen;
  760. $$.type = D_CONST;
  761. mb = $1;
  762. me = $3;
  763. if(mb < 0 || mb > 31 || me < 0 || me > 31){
  764. yyerror("illegal mask start/end value(s)");
  765. mb = me = 0;
  766. }
  767. if(mb <= me)
  768. v = ((ulong)~0L>>mb) & (~0L<<(31-me));
  769. else
  770. v = ~(((ulong)~0L>>(me+1)) & (~0L<<(31-(mb-1))));
  771. $$.offset = v;
  772. }
  773. ximm:
  774. '$' addr
  775. {
  776. $$ = $2;
  777. $$.type = D_CONST;
  778. }
  779. | '$' LSCONST
  780. {
  781. $$ = nullgen;
  782. $$.type = D_SCONST;
  783. memcpy($$.sval, $2, sizeof($$.sval));
  784. }
  785. fimm:
  786. '$' LFCONST
  787. {
  788. $$ = nullgen;
  789. $$.type = D_FCONST;
  790. $$.dval = $2;
  791. }
  792. | '$' '-' LFCONST
  793. {
  794. $$ = nullgen;
  795. $$.type = D_FCONST;
  796. $$.dval = -$3;
  797. }
  798. imm: '$' con
  799. {
  800. $$ = nullgen;
  801. $$.type = D_CONST;
  802. $$.offset = $2;
  803. }
  804. sreg:
  805. LREG
  806. | LR '(' con ')'
  807. {
  808. if($$ < 0 || $$ >= NREG)
  809. print("register value out of range\n");
  810. $$ = $3;
  811. }
  812. regaddr:
  813. '(' sreg ')'
  814. {
  815. $$ = nullgen;
  816. $$.type = D_OREG;
  817. $$.reg = $2;
  818. $$.offset = 0;
  819. }
  820. | '(' sreg '+' sreg ')'
  821. {
  822. $$ = nullgen;
  823. $$.type = D_OREG;
  824. $$.reg = $2;
  825. $$.xreg = $4;
  826. $$.offset = 0;
  827. }
  828. addr:
  829. name
  830. | con '(' sreg ')'
  831. {
  832. $$ = nullgen;
  833. $$.type = D_OREG;
  834. $$.reg = $3;
  835. $$.offset = $1;
  836. }
  837. name:
  838. con '(' pointer ')'
  839. {
  840. $$ = nullgen;
  841. $$.type = D_OREG;
  842. $$.name = $3;
  843. $$.sym = S;
  844. $$.offset = $1;
  845. }
  846. | LNAME offset '(' pointer ')'
  847. {
  848. $$ = nullgen;
  849. $$.type = D_OREG;
  850. $$.name = $4;
  851. $$.sym = $1;
  852. $$.offset = $2;
  853. }
  854. | LNAME '<' '>' offset '(' LSB ')'
  855. {
  856. $$ = nullgen;
  857. $$.type = D_OREG;
  858. $$.name = D_STATIC;
  859. $$.sym = $1;
  860. $$.offset = $4;
  861. }
  862. comma:
  863. | ','
  864. offset:
  865. {
  866. $$ = 0;
  867. }
  868. | '+' con
  869. {
  870. $$ = $2;
  871. }
  872. | '-' con
  873. {
  874. $$ = -$2;
  875. }
  876. pointer:
  877. LSB
  878. | LSP
  879. | LFP
  880. con:
  881. LCONST
  882. | LVAR
  883. {
  884. $$ = $1->value;
  885. }
  886. | '-' con
  887. {
  888. $$ = -$2;
  889. }
  890. | '+' con
  891. {
  892. $$ = $2;
  893. }
  894. | '~' con
  895. {
  896. $$ = ~$2;
  897. }
  898. | '(' expr ')'
  899. {
  900. $$ = $2;
  901. }
  902. expr:
  903. con
  904. | expr '+' expr
  905. {
  906. $$ = $1 + $3;
  907. }
  908. | expr '-' expr
  909. {
  910. $$ = $1 - $3;
  911. }
  912. | expr '*' expr
  913. {
  914. $$ = $1 * $3;
  915. }
  916. | expr '/' expr
  917. {
  918. $$ = $1 / $3;
  919. }
  920. | expr '%' expr
  921. {
  922. $$ = $1 % $3;
  923. }
  924. | expr '<' '<' expr
  925. {
  926. $$ = $1 << $4;
  927. }
  928. | expr '>' '>' expr
  929. {
  930. $$ = $1 >> $4;
  931. }
  932. | expr '&' expr
  933. {
  934. $$ = $1 & $3;
  935. }
  936. | expr '^' expr
  937. {
  938. $$ = $1 ^ $3;
  939. }
  940. | expr '|' expr
  941. {
  942. $$ = $1 | $3;
  943. }