API tools faq
paste
Guest User

BPEx2 Spec.isa

a guest
Nov 5th, 2026
5
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 31.68 KB | None | 0 0
raw download clone embed print report
  1. [settings]
  2. name = "BPEx2"
  3.  
  4. [fields]
  5. empty
  6. "" 0000000000000000
  7.  
  8. br
  9. "" 0
  10. "(" 0
  11. ")" 0
  12. "[" 0
  13. "]" 0
  14.  
  15. op
  16. "" 0
  17. "+" 0
  18. "-" 1
  19.  
  20. operator
  21. "" 0000
  22. "+" 0000
  23. "-" 0001
  24. "x" 0010
  25. "/" 0011
  26. "%" 0100
  27. BLO 0101
  28. DCD 1011
  29. storeCMP 1100
  30. cmp 1101
  31. cmpr 1110
  32. storage 1111
  33.  
  34. BLO
  35. "" 000
  36. "<<" 000
  37. ">>" 001
  38. asr 010
  39. nand 011
  40. or 100
  41. and 101
  42. nor 110
  43. xor 111
  44.  
  45. comparison
  46. nojmp 000
  47. CMP 000
  48. "==" 001
  49. ">=" 010
  50. ">" 011
  51. jmp 100
  52. "!=" 101
  53. "<" 110
  54. "<=" 111
  55.  
  56. register
  57. zr 00000
  58. r1 00001
  59. r2 00010
  60. r3 00011
  61. r4 00100
  62. r5 00101
  63. r6 00110
  64. r7 00111
  65. r8 01000
  66. r9 01001
  67. r10 01010
  68. r11 01011
  69. r12 01100
  70. r13 01101
  71. r14 01110
  72. r15 01111
  73. r16 10000
  74. r17 10001
  75. r18 10010
  76. r19 10011
  77. r20 10100
  78. tmp1 10101
  79. tmp2 10110
  80. sp 10111
  81. flags 11000
  82. in 11001
  83. out 11010
  84. keyboard 11011
  85. screen 11100
  86. clock0 11101
  87. clock1 11110
  88. counter 11111
  89.  
  90.  
  91.  
  92. [patterns]
  93.  
  94. /*
  95. =====================
  96. ==== Destination ====
  97. =====================
  98. */
  99.  
  100. // Register
  101. pattern destReg()
  102. %r(register)
  103. 00 00000000 00000000 00000000 000rrrrr
  104.  
  105.  
  106. // Tables
  107. pattern destTableImm()
  108. %r(register)[%i:U16(immediate)]
  109. %v = %r + %i
  110. 00 00000000 00000000 00000000 000vvvvv
  111.  
  112. pattern destTableReg()
  113. %r(register)[%g(register))]
  114. 00 00000000 00000000 000ggggg 000rrrrr
  115.  
  116. pattern destRamTableImm()
  117. %i:U16(immediate)[%u:U16(immediate)]
  118. %h = %u << 2
  119. %v = %i + %h
  120. 01 00000000 00000000 vvvvvvvv vvvvvvvv
  121.  
  122. pattern destRamTableReg()
  123. %i:U10(immediate)[%r(register)]
  124. 10 00000000 00000000 0iiiiiii iiirrrrr
  125.  
  126. pattern destRamTableRegImm()
  127. %i:U10(immediate)[%r(register) + %u:U10(immediate)]
  128. %h = %u << 2
  129. %v = %i + %h
  130. 10 00000000 00000000 0vvvvvvv vvvrrrrr
  131.  
  132.  
  133. // Pointers
  134. pattern destRegPointer()
  135. *%x(br)%g(register)%y(br)
  136. 00 00000000 00000000 000ggggg 00000000
  137.  
  138. pattern destRegDereferencePlsImm()
  139. &%x(br)%r(register) + %i:U16(immediate | empty)%y(br)
  140. %v = %r + %i
  141. 00 00000000 00000000 00000000 000vvvvv
  142.  
  143. pattern destRegDereferenceMnsImm()
  144. &%x(br)%r(register) - %i:U16(immediate | empty)%y(br)
  145. %v = %r - %i
  146. 00 00000000 00000000 00000000 000vvvvv
  147.  
  148. pattern destRegRegDereference()
  149. &%x(br)%r(register) %p(op) %g(register)%y(br)
  150. 00 00000000 00000000 p00ggggg 000rrrrr
  151.  
  152. pattern destRegPlsImm()
  153. %x(br)%r(register) + %i:U16(immediate | empty)%y(br)
  154. %v = %r + %i
  155. 00 00000000 00000000 00000000 000vvvvv
  156.  
  157. pattern destRegMnsImm()
  158. %x(br)%r(register) - %i:U16(immediate | empty)%y(br)
  159. %v = %r - %i
  160. 00 00000000 00000000 00000000 000vvvvv
  161.  
  162.  
  163. // RAM
  164. pattern destRamImm()
  165. ram[%i:U16(immediate)]
  166. 01 00000000 00000000 iiiiiiii iiiiiiii
  167.  
  168. pattern destRamRegImm()
  169. ram[%r(register) %p(op) %i:U10(immediate)]
  170. 10 00000000 00000000 piiiiiii iiirrrrr
  171.  
  172. pattern destRamRegReg()
  173. ram[%r(register) %p(op) %g(register)]
  174. 11 00000000 00000000 p00ggggg 000rrrrr
  175.  
  176.  
  177. // Destination
  178. pattern dest()
  179. %d[destReg() | destTableImm() | destTableReg() | destRamTableImm() | destRamTableReg() | destRamTableRegImm() | destRegPointer() | destRegDereferencePlsImm() | destRegDereferenceMnsImm() | destRegRegDereference() | destRegPlsImm() | destRegMnsImm() | destRamImm() | destRamRegImm() | destRamRegReg()]
  180. %type = %d[34:32]
  181. tt dddddddd dddddddd dddddddd dddddddd
  182.  
  183.  
  184.  
  185. /*
  186. =====================
  187. ======= Go to =======
  188. =====================
  189. */
  190.  
  191. // Immediate value
  192. pattern gotoImm()
  193. %i:U16(immediate)
  194. %v = %i - 1
  195. 01 00000000 00000000 vvvvvvvv vvvvvvvv
  196.  
  197.  
  198. // Labels
  199. pattern gotoLabel()
  200. %i(label)
  201. %v = %i >> 3
  202. 01 00000000 00000000 vvvvvvvv vvvvvvvv
  203.  
  204. pattern gotoLabelPlsImm()
  205. %x(br)%l(label) + %i:U16(immediate)%y(br)
  206. %h = %l >> 3
  207. %v = %h + %i
  208. 01 00000000 00000000 vvvvvvvv vvvvvvvv
  209.  
  210. pattern gotoLabelMnsImm()
  211. %x(br)%l:U16(label) - %i:U16(immediate)%y(br)
  212. %h = %l >> 3
  213. %v = %h - %i
  214. 01 00000000 00000000 vvvvvvvv vvvvvvvv
  215.  
  216.  
  217. // Register
  218. pattern gotoRegImm()
  219. %x(br)%r(register) %p(op) %i:U10(immediate | empty)%y(br)
  220. 00 00000000 00000000 piiiiiii iiirrrrr
  221.  
  222.  
  223. // RAM
  224. pattern gotoRamImm()
  225. ram[%i:U16(label)]
  226. 10 00000000 00000000 iiiiiiii iiiiiiii
  227.  
  228. pattern gotoRamReg()
  229. ram[%r(register)]
  230. 11 00000000 00000000 00000000 000rrrrr
  231.  
  232. pattern gotoRamRegReg()
  233. ram[%x(br)%r(register) %p(op) %g(register | empty)%y(br)]
  234. 11 00000000 00000000 p00gggggg 000rrrrr
  235.  
  236.  
  237. // GOTO
  238. pattern goto()
  239. %d[gotoRegImm() | gotoImm() | gotoLabel() | gotoLabelPlsImm() | gotoLabelMnsImm() | gotoRamImm() | gotoRamReg() | gotoRamRegReg()]
  240. %type = %d[34:32]
  241. tt dddddddd dddddddd dddddddd dddddddd
  242.  
  243.  
  244.  
  245. /*
  246. =====================
  247. ===== Arguments =====
  248. =====================
  249. */
  250.  
  251. pattern empty()
  252. %e:U16(empty)
  253. 000 00000000 00000000 eeeeeeee eeeeeeee
  254.  
  255.  
  256. // Immediate values
  257. pattern imm16()
  258. %i:S16(immediate | label)
  259. 000 00000000 00000000 iiiiiiii iiiiiiii
  260.  
  261. pattern imm32()
  262. %i:S32(immediate | label)
  263. 000 iiiiiiii iiiiiiii iiiiiiii iiiiiiii
  264.  
  265.  
  266. // Registers
  267. pattern regImm()
  268. %x(br)%r(register) %p(op) %i:U10(immediate | empty)%y(br)
  269. 001 00000000 00000000 piiiiiii iiirrrrr
  270.  
  271. pattern regReg()
  272. %x(br)%r(register) %p(op) %g(register)%y(br)
  273. 010 00000000 00000000 p00ggggg 000rrrrr
  274.  
  275.  
  276. // Tables
  277. pattern TableImmPls()
  278. %r(register)[%i:U10(immediate)]
  279. %v = %r + %i
  280. 011 00000000 00000000 00000000 000vvvvv
  281.  
  282. pattern TableImmPlsImm()
  283. %r(register)[%i:U10(immediate) + %u:U10(immediate)]
  284. %v = %r + %i + %u
  285. 011 00000000 00000000 00000000 000vvvvv
  286.  
  287. pattern TableImmMnsImm()
  288. %r(register)[%i:U10(immediate) - %u:U10(immediate)]
  289. %v = %r + %i - %u
  290. 011 00000000 00000000 00000000 000vvvvv
  291.  
  292. pattern TableReg()
  293. %r(register)[%g(register)]
  294. 011 00000000 00000000 000ggggg 000rrrrr
  295.  
  296.  
  297.  
  298.  
  299. // Pointers
  300. pattern regPointer()
  301. *%x(br)%g(register)%y(br)
  302. 011 00000000 00000000 000ggggg 00000000
  303.  
  304. pattern regRegPointer()
  305. *%x(br) %r(register) %p(op) %g(register)%y(br)
  306. 011 00000000 00000000 p00ggggg 000rrrrr
  307.  
  308. pattern dereferencePointer()
  309. &%r(register)
  310. 000 00000000 00000000 00000000 000rrrrr
  311.  
  312.  
  313. // RAM
  314. pattern ramImm()
  315. ram[%i:U16(immediate)]
  316. 101 iiiiiiii iiiiiiii iiiiiiii iiiiiiii
  317.  
  318. pattern ramRegImm()
  319. ram[%r(register) %p(op) %i:U10(immediate | empty)]
  320. 110 00000000 00000000 piiiiiii iiirrrrr
  321.  
  322. pattern ramRegReg()
  323. ram[%r(register) %p(op) %g(register)]
  324. 111 00000000 00000000 p00ggggg 000rrrrr
  325.  
  326.  
  327. // CMP
  328. pattern cmpToReg()
  329. %c(comparison)
  330. 000 00000000 00000000 00000000 00000ccc //r16 to r20, tmp1 and tmp 2
  331.  
  332.  
  333. // ARGUMENT
  334. pattern arg()
  335. %a[empty() | imm16() | imm32() | regImm() | regReg() | TableImmPls() | TableImmPlsImm() | TableImmMnsImm() | TableReg() | regPointer() | regRegPointer() | dereferencePointer() | ramImm() | ramRegImm() | ramRegReg() | cmpToReg()]
  336. %type = %a[34:32]
  337. ttt aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa
  338.  
  339.  
  340.  
  341. /*
  342. =====================
  343. ===== Operators =====
  344. =====================
  345. */
  346.  
  347. pattern MATH()
  348. %o(operator)
  349. 0000%o[3:0]
  350.  
  351. pattern BLO()
  352. %c(BLO)
  353. %c[2:0]0101
  354.  
  355. pattern CMP()
  356. %c(comparison)
  357. %c[2:0]1100
  358.  
  359. pattern operator()
  360. %o[MATH() | BLO() | CMP()]
  361. 0%o[6:0]
  362.  
  363.  
  364.  
  365. /*
  366. ======================
  367. ==== Conditionals ====
  368. ======================
  369. */
  370.  
  371. pattern imm11()
  372. %i:S11(immediate)
  373. 001 iiiiiiii iii
  374.  
  375. pattern reg11()
  376. %r(register)
  377. 010 000rrrrr 000
  378.  
  379. pattern DCD()
  380. %x(br)%r(register) %c(comparison) %i[imm11() | reg11()]%y(br)
  381. ccc %i[13:11] 00000000 00000000 %i[10:0]rrrrr
  382.  
  383. pattern IsRegTRUE()
  384. %x(br)%r(register)%y(br)
  385. 101 001 00000000 00000000 00000000 000rrrrr
  386.  
  387.  
  388.  
  389. /*
  390. =====================
  391. ==== Comparisons ====
  392. =====================
  393. */
  394.  
  395. pattern cmpReg()
  396. %c(register) //r16 to r20, tmp1 and tmp 2
  397. 1110 00000ccc
  398.  
  399. pattern cmpImm()
  400. %c(comparison)
  401. 1101 00000ccc
  402.  
  403. pattern comparison()
  404. %c[cmpReg() | cmpImm()]
  405. %type = %c[11:8]
  406. tttt 00000ccc
  407.  
  408.  
  409. [instructions]
  410.  
  411. // do nothing
  412. nop
  413. 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
  414.  
  415. // ====== General ======
  416.  
  417. %dest[dest()] = %a[arg()] %o[operator()] %b[arg()]
  418. oooooooo %dest[33:32]%a[34:32]%b[34:32] %dest[15:0] %a[15:0] %b[15:0]
  419.  
  420. // ====== Stack ======
  421. stack.push%z(br)%b[arg()]%x(br)
  422. 00011111 10000%b[34:32] 00000000 00010111 %b[31:0]
  423. # Sends %b to stack. Decreases sp by 4.
  424.  
  425. %dest[dest()] = stack.pop()
  426. 00101111 %dest[33:32]110000 %dest[15:0] 00000000 00010111 00000000 00000000
  427. # Pops first value from stack to %dest. Increases sp by 4.
  428.  
  429. stack.pop()
  430. 00101111 00110000 00000000 00000000 00000000 00010111 00000000 00000000
  431. # Pops first value from stack. Increases sp by 4.
  432.  
  433. %dest[dest()] = stack.peek()
  434. 00000000 %dest[33:32]110000 %dest[15:0] 00000000 00010111 00000000 00000000
  435. # Copies the first value on stack to %dest.
  436.  
  437. // ====== Conditionals ======
  438.  
  439. %dest[dest()] = %DCD[DCD() | IsRegTRUE()] ? %b(register) : %i[imm11() | reg11()]
  440. 0%DCD[37:35]1011 %dest[33:32]%DCD[34:32]%i[13:11] %dest[15:0] %DCD[15:0] %i[10:0]bbbbb
  441.  
  442. if %DCD[DCD() | IsRegTRUE()] then %dest[dest()] = %b(register) %o(operator) %i[imm11() | reg11()]
  443. 0%DCD[37:35]oooo %dest[33:32]%DCD[34:32]%i[13:11] %dest[15:0] %DCD[15:0] %i[10:0]bbbbb
  444.  
  445.  
  446. // ====== Jumps ======
  447. goto %dest[goto()] if %a[arg()] %c[comparison()] %b[arg()]
  448. %operator= %c[11:8]
  449. ccc0%operator[3:0] %dest[33:32]%a[34:32]%b[34:32] %dest[15:0] %a[15:0] %b[15:0]
  450. # Jumps to %dest if %a %c %b
  451.  
  452. goto %dest[goto()]
  453. 00101101 %dest[33:32]000000 %dest[15:0] 00000000 00000000 00000000 00000000
  454. # Jumps to %dest.
  455.  
  456.  
  457. // ====== Cycles ======
  458.  
  459. // External FOR cycle using Register
  460. %forend(label) (%current(register) = %start[arg()]; %throwaway(register) %comp(comparison) %final[arg()]; %increment[arg()])
  461. %start_type = %start[34:32]
  462. %increment_type = %increment[34:32]
  463. %final_type = %final[34:32]
  464. %h = %forend >> 3
  465. %value = %h + 1
  466. %inverseComp = %comp ^ 4
  467. 00000000 00%start_type[2:0]000 00000000 000%current[4:0] %start[15:0] 00000000 00000000 00101111 10000001 00000000 00010111 00000000 00000000 00000000 01011111 10001101 00000000 00000000 01011111 00000000 00000000 00000000 00000000 00000000 00001%increment_type[2:0] 00000000 000%current[4:0] 00000000 000%current[4:0] %increment[15:0] %inverseComp[2:0]01101 01001%final_type[2:0] %value[15:0] 00000000 000%current[4:0] %final[15:0]
  468.  
  469. // END for external FOR cycle.
  470. // To be used with forendlabel such as for1:end.
  471. end
  472. 10001101 11000000 00000000 00010111 00000000 00000000 00000000 00000000 00000000 00001000 00000000 00010111 00000000 00010111 00000000 00000100
  473.  
  474.  
  475.  
  476.  
  477.  
  478.  
  479.  
  480.  
  481. ;%m:U2(dest_type)%d:U16(immediate)%z(bracket) = %f:U3(type)%a:U16(immediate) %o:U4(operant)
  482. ;0000oooo mmfff000 dddddddd dddddddd aaaaaaaa aaaaaaaa 00000000 00000000
  483.  
  484. ;%m:U2(dest_type)%d:U16(immediate)%z(bracket) = %f:U3(type)%a:U16(immediate) %o:U4(operant) %g:U3(type)%b:U16(immediate)%x(bracket)
  485. ;0000oooo mmfffggg dddddddd dddddddd aaaaaaaa aaaaaaaa bbbbbbbb bbbbbbbb
  486.  
  487.  
  488. /*
  489. //
  490. // IO instructions
  491. //
  492.  
  493. %m:U2(dest_type)%d:U16(immediate)%z(bracket) = %f:U3(type)%a:U16(immediate)%y(bracket) %o:U4(operant) %g:U3(type)%b:U16(immediate)%x(bracket)
  494. 0000oooo mmfffggg dddddddd dddddddd aaaaaaaa aaaaaaaa bbbbbbbb bbbbbbbb
  495.  
  496.  
  497. nop
  498. 00000000 00000000 00000000 00000000
  499. # Does nothing.
  500.  
  501. ;%a(register) = in
  502. ;00000001 aaaa0000 00000000 00000000
  503. ;# Loads an input and stores it in %a.
  504.  
  505. out = %b(register)
  506. 00000010 00000000 0000bbbb 00000000
  507. # Sends %b to output.
  508.  
  509. out = %a:U16(immediate)
  510. 00010010 00000000 aaaaaaaa aaaaaaaa
  511. # Sends %a to output.
  512.  
  513. %a(register) = kb
  514. 00000011 aaaa0000 00000000 00000000
  515. # Loads keyboard input and stores it to %a.
  516.  
  517. screen[%a(register)] = %b(register)
  518. 00000100 0000aaaa 0000bbbb 00000000
  519. # Stores the value of %b in screen setting %a.
  520.  
  521. screen[%a(register)] = %b:U16(immediate)
  522. 00010100 0000aaaa bbbbbbbb bbbbbbbb
  523. # Stores the value of %b in screen setting %a.
  524.  
  525. %a(register) = time0
  526. 00000101 aaaa0000 00000000 00000000
  527. # Loads the lower four bytes of the time value and stores it to %a.
  528.  
  529. %a(register) = time1
  530. 00000110 aaaa0000 00000000 00000000
  531. # Loads the upper four bytes of the time value and stores it to %a.
  532.  
  533. %a(register) = counter
  534. 00000111 aaaa0000 00000000 00000000
  535. # Loads the counter value and stores it to %a.
  536.  
  537. %a(register) = counter + %b:U16(immediate)
  538. 00010111 aaaa0000 bbbbbbbb bbbbbbbb
  539. # Loads the counter value and stores it to %a.
  540.  
  541. %a(register) = counter + %b(register)
  542. 00000111 aaaa0000 0000bbbb 00000000
  543. # Loads the counter value and stores it to %a.
  544.  
  545.  
  546. //
  547. // Register instructions
  548. //
  549.  
  550. %a(register) = %b(register)
  551. 00100001 aaaa0000 0000bbbb 00000000
  552. # Moves a value to %a from %b.
  553.  
  554. %a(register) = R|%b:U4(immediate)
  555. 00100001 aaaa0000 0000bbbb 00000000
  556. # Moves a value to %a from %b.
  557.  
  558. %a(register) = neg(%b(register))
  559. 00100101 aaaa0000 0000bbbb 00000000
  560. # Negates a %b and stores it in %a.
  561.  
  562. %a(register) = !%b(register)
  563. 00100011 aaaa0000 0000bbbb 00000000
  564. # Toggles the bits of %b and stores it in %a.
  565.  
  566. %a(register) = %b(register) nand %c(register)
  567. 00100000 aaaabbbb 0000cccc 00000000
  568. # NAND %b and %c and stores the result in %a.
  569.  
  570. %a(register) = %b(register) or %c(register)
  571. 00100001 aaaabbbb 0000cccc 00000000
  572. # OR %b and %c and stores the result in %a.
  573.  
  574. %a(register) = %b(register) and %c(register)
  575. 00100010 aaaabbbb 0000cccc 00000000
  576. # AND %b and %c and stores the result in %a.
  577.  
  578. %a(register) = %b(register) nor %c(register)
  579. 00100011 aaaabbbb 0000cccc 00000000
  580. # NOR %b and %c and stores the result in %a.
  581.  
  582. %a(register) = %b(register) xor %c(register)
  583. 00100100 aaaabbbb 0000cccc 00000000
  584. # XOR %b and %c and stores the result in %a.
  585.  
  586. %a(register) = %b(register) << %c(register)
  587. 00100101 aaaabbbb 0000cccc 00000000
  588. # Logical shifts left %b by %c and stores the result in %a.
  589.  
  590. %a(register) = %b(register) >> %c(register)
  591. 00100110 aaaabbbb 0000cccc 00000000
  592. # Logical shifts right %b by %c and stores the result in %a.
  593.  
  594. %a(register) = %b(register) + %c(register)
  595. 00100111 aaaabbbb 0000cccc 00000000
  596. # ADD %b and %c and stores the result in %a.
  597.  
  598. %a(register) = %b(register) - %c(register)
  599. 00101000 aaaabbbb 0000cccc 00000000
  600. # SUB %b and %c and stores the result in %a.
  601.  
  602. %a(register) = %b(register) asr %c(register)
  603. 00101001 aaaabbbb 0000cccc 00000000
  604. # Arithmetic shift right %b by %c and stores the result in %a.
  605.  
  606. %a(register) = %b(register) * %c(register)
  607. 00101010 aaaabbbb 0000cccc 00000000
  608. # MUL %b and %c and stores the result in %a.
  609.  
  610. %a(register) = %b(register) / %c(register)
  611. 00101011 aaaabbbb 0000cccc 00000000
  612. # DIV %b and %c and stores the result in %a.
  613.  
  614. %a(register) = %b(register) mod %c(register)
  615. 00101100 aaaabbbb 0000cccc 00000000
  616. # DIV %b and %c and stores the result in %a.
  617.  
  618. cmp %a(register), %b(register)
  619. 00101101 1111aaaa 0000bbbb 00000000
  620. # Compares %a and %b and stores the result in the 'flags' register.
  621.  
  622. %a(register) = merge32(%b(register),%c(register))
  623. 00101110 aaaabbbb 0000cccc 00000000
  624. # Arithmetic shift right %b by %c and stores the result in %a.
  625.  
  626. %a(register) = lower16(%b(register))
  627. 00101111 aaaa0000 0000bbbb 00000000
  628. # Toggles the bits of %b and stores it in %a.
  629.  
  630. %a(register) = upper16(%b(register))
  631. 00111001 aaaabbbb 00000000 00010000
  632. # Toggles the bits of %b and stores it in %a.
  633.  
  634.  
  635. if %a(register) == %b(register) goto %c:U16(immediate | label)
  636. 00101010 1111aaaa 0000bbbb 00000000 01010001 00001111 cccccccc cccccccc
  637. # Compares %a and %b, stores the result in the 'flags' register and jumps to %c if %a and %c are equal.
  638.  
  639. if %a(register) == %b(register) goto %c(register)
  640. 00101010 1111aaaa 0000bbbb 00000000 01000001 00001111 0000cccc 00000000
  641. # Compares %a and %b, stores the result in the 'flags' register and jumps to %c if %a and %c are equal.
  642.  
  643. if %a(register) != %b(register) goto %c:U16(immediate | label)
  644. 00101010 1111aaaa 0000bbbb 00000000 01011001 00001111 cccccccc cccccccc
  645. # Compares %a and %b, stores the result in the 'flags' register and jumps to %c if %a and %c are not equal.
  646.  
  647. if %a(register) != %b(register) goto %c(register)
  648. 00101010 1111aaaa 0000bbbb 00000000 01001001 00001111 0000cccc 00000000
  649. # Compares %a and %b, stores the result in the 'flags' register and jumps to %c if %a and %c are equal.
  650.  
  651. if %a(register) <= %b(register) goto %c(register)
  652. 00101010 1111aaaa 0000bbbb 00000000 01000101 00001111 0000cccc 00000000
  653.  
  654. if %a(register) >= %b(register) goto %c(register)
  655. 00101010 1111aaaa 0000bbbb 00000000 01001100 00001111 0000cccc 00000000
  656.  
  657. //
  658. // Immediate instructions
  659. //
  660.  
  661. %a(register) = %b:S16(immediate | label)
  662. 00110001 aaaa0000 bbbbbbbb bbbbbbbb
  663. # Moves a value to %a.
  664.  
  665. %a(register) = neg(%b:U16(immediate | label))
  666. 00110101 aaaa0000 bbbbbbbb bbbbbbbb
  667. # Negates a value and stores it in %a.
  668.  
  669. %a(register) = !%b:S16(immediate | label)
  670. 00110011 aaaa0000 bbbbbbbb bbbbbbbb
  671. # Toggles the bits of a value and stores it in %a.
  672.  
  673. %a(register) = %b(register) nand %c:S16(immediate | label)
  674. 00110000 aaaabbbb cccccccc cccccccc
  675. # NAND %b and %c and stores the result in %a.
  676.  
  677. %a(register) = %b(register) or %c:S16(immediate | label)
  678. 00110001 aaaabbbb cccccccc cccccccc
  679. # OR %b and %c and stores the result in %a.
  680.  
  681. %a(register) = %b(register) and %c:S16(immediate | label)
  682. 00110010 aaaabbbb cccccccc cccccccc
  683. # AND %b and %c and stores the result in %a.
  684.  
  685. %a(register) = %b(register) nor %c:S16(immediate | label)
  686. 00110011 aaaabbbb cccccccc cccccccc
  687. # NOR %b and %c and stores the result in %a.
  688.  
  689. %a(register) = %b(register) xor %c:S16(immediate | label)
  690. 00110100 aaaabbbb cccccccc cccccccc
  691. # XOR %b and %c and stores the result in %a.
  692.  
  693. %a(register) = %b(register) << %c:S16(immediate | label)
  694. 00110101 aaaabbbb cccccccc cccccccc
  695. # Logical shifts left %b by %c and stores the result in %a.
  696.  
  697. %a(register) = %b(register) >> %c:S16(immediate | label)
  698. 00110110 aaaabbbb cccccccc cccccccc
  699. # Logical shifts right %b by %c and stores the result in %a.
  700.  
  701. %a(register) = %b(register) + %c:S16(immediate | label)
  702. 00110111 aaaabbbb cccccccc cccccccc
  703. # ADD %b and %c and stores the result in %a.
  704.  
  705. %a(register) = %b(register) - %c:S16(immediate | label)
  706. 00111000 aaaabbbb cccccccc cccccccc
  707. # SUB %b and %c and stores the result in %a.
  708.  
  709. %a(register) = %b(register) asr %c:S16(immediate | label)
  710. 00111001 aaaabbbb cccccccc cccccccc
  711. # Arithmetic shifts right %b and %c and stores the result in %a.
  712.  
  713. %a(register) = %b(register) * %c:S16(immediate | label)
  714. 00111010 aaaabbbb cccccccc cccccccc
  715. # MUL %b and %c and stores the result in %a.
  716.  
  717. %a(register) = %b(register) / %c:S16(immediate | label)
  718. 00111011 aaaabbbb cccccccc cccccccc
  719. # DIV %b and %c and stores the result in %a.
  720.  
  721. %a(register) = %b(register) mod %c:S16(immediate | label)
  722. 00111100 aaaabbbb cccccccc cccccccc
  723. # DIV %b and %c and stores the result in %a.
  724.  
  725. cmp %a(register), %b:U16(immediate)
  726. 00111101 1111aaaa bbbbbbbb bbbbbbbb
  727.  
  728. if %a(register) == %b:U16(immediate) goto %c:U16(immediate | label)
  729. 00111010 1111aaaa bbbbbbbb bbbbbbbb 01010001 00001111 cccccccc cccccccc
  730. # Compares %a and %b, stores the result in the 'flags' register and jumps to %c if %a and %c are equal.
  731.  
  732. if %a(register) != %b:U16(immediate) goto %c:U16(immediate | label)
  733. 00111010 1111aaaa bbbbbbbb bbbbbbbb 01011001 00001111 cccccccc cccccccc
  734. # Compares %a and %b, stores the result in the 'flags' register and jumps to %c if %a and %c are not equal.
  735.  
  736. if %a(register) > %b:U16(immediate) goto %c(register)
  737. 00111010 1111aaaa bbbbbbbb bbbbbbbb 01001101 00001111 0000cccc 00000000
  738. # Compares %a and %b, stores the result in the 'flags' register and jumps to %c if %a > %c.
  739.  
  740.  
  741.  
  742. //
  743. // Jump instructions
  744. //
  745.  
  746. je %a:U16(immediate | label)
  747. 01010001 00001111 aaaaaaaa aaaaaaaa
  748. # Jumps to %a if the values were equal (reading results from 'flags').
  749.  
  750. jb %a:U16(immediate | label)
  751. 01010010 00001111 aaaaaaaa aaaaaaaa
  752. # Jumps to %a if the first value was below (unsigned) the second (reading results from 'flags').
  753.  
  754. jb %a(register)
  755. 01000010 00001111 0000aaaa 00000000
  756. # Jumps to %a if the first value was below (unsigned) the second (reading results from 'flags').
  757.  
  758. jbe %a:U16(immediate | label)
  759. 01010011 00001111 aaaaaaaa aaaaaaaa
  760. # Jumps to %a if the First value was below (unsigned) or equal to the second (reading results from 'flags').
  761.  
  762. jbe %a(register)
  763. 01000011 00001111 0000aaaa 00000000
  764. # Jumps to %a if the First value was below (unsigned) or equal to the second (reading results from 'flags').
  765.  
  766. jl %a:U16(immediate | label)
  767. 01010100 00001111 aaaaaaaa aaaaaaaa
  768. # Jumps to %a if the first value was less (signed) than the second (reading results from 'flags').
  769.  
  770. jl %a(register)
  771. 01000100 00001111 0000aaaa 00000000
  772. # Jumps to %a if the first value was less (signed) than the second (reading results from 'flags').
  773.  
  774. jle %a:U16(immediate | label)
  775. 01010101 00001111 aaaaaaaa aaaaaaaa
  776. # Jumps to %a if the first value was less (signed) or equal to the second (reading results from 'flags').
  777.  
  778. jle %a(register)
  779. 01000101 00001111 0000aaaa 00000000
  780. # Jumps to %a if the first value was less (signed) or equal to the second (reading results from 'flags').
  781.  
  782. jmp %a(register)
  783. 01001000 00001111 0000aaaa 00000000
  784. # Jumps to %a.
  785.  
  786. jmp %a:U16(immediate | label)
  787. 01011000 00001111 aaaaaaaa aaaaaaaa
  788. # Jumps to %a.
  789.  
  790. jne %a:U16(immediate | label)
  791. 01011001 00001111 aaaaaaaa aaaaaaaa
  792. # Jumps to %a if the values were not equal (reading results from 'flags').
  793.  
  794. jae %a:U16(immediate | label)
  795. 01011010 00001111 aaaaaaaa aaaaaaaa
  796. # Jumps to %a if the first value was above (unsigned) or equal to the second (reading results from 'flags').
  797.  
  798. jae %a(register)
  799. 01001010 00001111 0000aaaa 00000000
  800. # Jumps to %a if the first value was above (unsigned) or equal to the second (reading results from 'flags').
  801.  
  802. ja %a:U16(immediate | label)
  803. 01011011 00001111 aaaaaaaa aaaaaaaa
  804. # Jumps to %a if the first value was above (unsigned) the second (reading results from 'flags').
  805.  
  806. ja %a(register)
  807. 01001011 00001111 0000aaaa 00000000
  808. # Jumps to %a if the first value was above (unsigned) the second (reading results from 'flags').
  809.  
  810. jge %a:U16(immediate | label)
  811. 01011100 00001111 aaaaaaaa aaaaaaaa
  812. # Jumps to %a if the first value was greater (signed) or equal to the second (reading results from 'flags').
  813.  
  814. jge %a(register)
  815. 01001100 00001111 0000aaaa 00000000
  816. # Jumps to %a if the first value was greater (signed) or equal to the second (reading results from 'flags').
  817.  
  818. jg %a:U16(immediate | label)
  819. 01011101 00001111 aaaaaaaa aaaaaaaa
  820. # Jumps to %a if the first value was greater (signed) than the second (reading results from 'flags').
  821.  
  822. jg %a(register)
  823. 01001101 00001111 0000aaaa 00000000
  824. # Jumps to %a if the first value was greater (signed) than the second (reading results from 'flags').
  825.  
  826.  
  827. //
  828. // Storage instructions
  829. //
  830.  
  831. %dest(register) = load8[%adr(register)]
  832. 01100000 dddd0000 0000aaaa 00000000
  833. # Loads address %adr from main memory and stores it to %dest.
  834.  
  835. %dest(register) = load8[%adr:U16(immediate)]
  836. 01110000 dddd0000 aaaaaaaa aaaaaaaa
  837. # Loads address %adr from main memory and stores it to %dest.
  838.  
  839. %dest(register) = load16[%adr(register)]
  840. 01100001 dddd0000 0000aaaa 00000000
  841. # Loads address %adr from main memory and stores it to %dest.
  842.  
  843. %dest(register) = load16[%adr:U16(immediate)]
  844. 01110001 dddd0000 aaaaaaaa aaaaaaaa
  845. # Loads address %adr from main memory and stores it to %dest.
  846.  
  847. %dest(register) = load32[%adr(register)]
  848. 01100010 dddd0000 0000aaaa 00000000
  849. # Loads address %adr from main memory and stores it to %dest.
  850.  
  851. %dest(register) = load32[%adr:U16(immediate)]
  852. 01110010 dddd0000 aaaaaaaa aaaaaaaa
  853. # Loads address %adr from main memory and stores it to %dest.
  854.  
  855. %dest(register) = pload[%adr(register)]
  856. 01100011 dddd0000 0000aaaa 00000000
  857. # Loads address %adr from persistent memory and stores it to %dest.
  858.  
  859. %dest(register) = pload[%adr:U16(immediate)]
  860. 01110011 dddd0000 aaaaaaaa aaaaaaaa
  861. # Loads address %adr from persistent memory and stores it to %dest.
  862.  
  863. store8[%adr(register)] = %value(register)
  864. 01100100 0000vvvv 0000aaaa 00000000
  865. # Stores %value to address %adr in main memory.
  866.  
  867. store8[%adr:U16(immediate)] = %value(register)
  868. 01110100 0000vvvv aaaaaaaa aaaaaaaa
  869. # Stores %value to address %adr in main memory.
  870.  
  871. store16[%adr(register)] = %value(register)
  872. 01100101 0000vvvv 0000aaaa 00000000
  873. # Stores %value to address %adr in main memory.
  874.  
  875. store16[%adr:U16(immediate)] = %value(register)
  876. 01110101 0000vvvv aaaaaaaa aaaaaaaa
  877. # Stores %value to address %adr in main memory.
  878.  
  879. store32[%adr(register)] = %value(register)
  880. 01100110 0000vvvv 0000aaaa 00000000
  881. # Stores %value to address %adr in main memory.
  882.  
  883. store32[%adr:U16(immediate)] = %value(register)
  884. 01110110 0000vvvv aaaaaaaa aaaaaaaa
  885. # Stores %value to address %adr in main memory.
  886.  
  887. pstore[%adr(register)] = %value(register)
  888. 01100111 0000vvvv 0000aaaa 00000000
  889. # Stores %value to address %adr in persistent memory.
  890.  
  891. pstore[%adr:U16(immediate)] = %value(register)
  892. 01110111 0000vvvv aaaaaaaa aaaaaaaa
  893. # Stores %value to address %adr in persistent memory.
  894.  
  895.  
  896. //
  897. // Stack instructions
  898. //
  899.  
  900. stack.push(%a(register))
  901. 00111000 11101110 00000000 00000100 01100110 0000aaaa 00001110 00000000
  902. # Pushes %a onto the stack. This instruction is a synonym for: sub sp, sp, 4 store_32 [sp], %a
  903.  
  904. %a(register) = stack.peek()
  905. 01100010 aaaa0000 00001110 00000000
  906. # Retrieve topmost value from stack without removing it.
  907.  
  908. stack.pop()
  909. 00110111 11101110 00000000 00000100
  910. # Decreases the stack counter which removes the topmost value from the stack
  911.  
  912. %a(register) = stack.pop()
  913. 01100010 aaaa0000 00001110 00000000 00110111 11101110 00000000 00000100
  914. # Pops %a off the stack. This instruction is a synonym for: load_32 %a, [sp] add sp, sp, 4
  915.  
  916.  
  917.  
  918. //
  919. // Cycle instructions
  920. //
  921.  
  922. // Internal register
  923. for (i = %a:S16(immediate); i < %b:S16(immediate); %c:S16(immediate))
  924. 00110001 11000000 aaaaaaaa aaaaaaaa 00110001 11010000 cccccccc cccccccc 00101110 11011100 00001101 00000000 00111000 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00110001 11000000 bbbbbbbb bbbbbbbb 00111000 11001100 aaaaaaaa aaaaaaaa 00111011 11001100 cccccccc cccccccc 00010111 11010000 00000000 00001000 00101110 11011100 00001101 00000000 01100010 11000000 00001110 00000000 00110111 11101110 00000000 00000100 00111000 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00111000 11101110 00000000 00000100 01100110 00001100 00001110 00000000
  925.  
  926. for (i = %a:S16(immediate); i > %b:S16(immediate); %c:S16(immediate))
  927. 00110001 11000000 aaaaaaaa aaaaaaaa 00110001 11010000 cccccccc cccccccc 00101110 11011100 00001101 00000000 00111000 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00110001 11000000 bbbbbbbb bbbbbbbb 00111000 11001100 aaaaaaaa aaaaaaaa 00111011 11001100 cccccccc cccccccc 00010111 11010000 00000000 00001000 00101110 11011100 00001101 00000000 01100010 11000000 00001110 00000000 00110111 11101110 00000000 00000100 00111000 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00111000 11101110 00000000 00000100 01100110 00001100 00001110 00000000
  928.  
  929. for (i = %a:S16(immediate); i >= %b:S16(immediate); %c:S16(immediate))
  930. 00110001 11000000 aaaaaaaa aaaaaaaa 00110001 11010000 cccccccc cccccccc 00101110 11011100 00001101 00000000 00111000 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00110001 11000000 bbbbbbbb bbbbbbbb 00111000 11001100 aaaaaaaa aaaaaaaa 00111011 11001100 cccccccc cccccccc 00110111 11001100 00000000 00000001 00010111 11010000 00000000 00001000 00101110 11011100 00001101 00000000 01100010 11000000 00001110 00000000 00110111 11101110 00000000 00000100 00111000 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00111000 11101110 00000000 00000100 01100110 00001100 00001110 00000000
  931.  
  932. for (i = %a:S16(immediate); i <= %b:S16(immediate); %c:S16(immediate))
  933. 00110001 11000000 aaaaaaaa aaaaaaaa 00110001 11010000 cccccccc cccccccc 00101110 11011100 00001101 00000000 00111000 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00110001 11000000 bbbbbbbb bbbbbbbb 00111000 11001100 aaaaaaaa aaaaaaaa 00111011 11001100 cccccccc cccccccc 00110111 11001100 00000000 00000001 00010111 11010000 00000000 00001000 00101110 11011100 00001101 00000000 01100010 11000000 00001110 00000000 00110111 11101110 00000000 00000100 00111000 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00111000 11101110 00000000 00000100 01100110 00001100 00001110 00000000
  934.  
  935. %a(register) = (i)
  936. 01100010 aaaa0000 00001110 00000000 00101111 aaaa0000 0000aaaa 00000000
  937.  
  938. endfor
  939. 01100010 11000000 00001110 00000000 00110111 11101110 00000000 00000100 00111001 11011100 00000000 00010000 00100111 11001100 00001101 00000000 01100010 11010000 00001110 00000000 00110111 11101110 00000000 00000100 00111000 11101110 00000000 00000100 01100110 00001100 00001110 00000000 00111000 11011101 00000000 00000001 00101111 11000000 00001101 00000000 00111101 11111100 00000000 00000000 00111001 11001101 00000000 00010000 01001101 00001111 00001100 00000000 00110111 11101110 00000000 00000100
  940.  
  941.  
  942. // User Defined Register
  943. for (%d(register) = %a:S16(immediate); %e(register) > %b:S16(immediate); %c:S16(immediate))
  944. 00110001 dddd0000 aaaaaaaa aaaaaaaa 00110001 11000000 bbbbbbbb bbbbbbbb 00110101 11001100 aaaaaaaa aaaaaaaa 00111100 11001100 cccccccc cccccccc 00000111 11010000 00000000 00000000 00110100 11011101 00000000 00001100 00101110 11011100 00001101 00000000 00110101 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00110001 11000000 cccccccc cccccccc 00110101 11101110 00000000 00000100 01100110 00001100 00001110 00000000
  945.  
  946. for (%d(register) = %a:S16(immediate); %e(register) < %b:S16(immediate); %c:S16(immediate))
  947. 00110001 dddd0000 aaaaaaaa aaaaaaaa 00110001 11000000 bbbbbbbb bbbbbbbb 00110101 11001100 aaaaaaaa aaaaaaaa 00111100 11001100 cccccccc cccccccc 00000111 11010000 00000000 00000000 00110100 11011101 00000000 00001100 00101110 11011100 00001101 00000000 00110101 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00110001 11000000 cccccccc cccccccc 00110101 11101110 00000000 00000100 01100110 00001100 00001110 00000000
  948.  
  949. for (%d(register) = %a:S16(immediate); %e(register) >= %b:S16(immediate); %c:S16(immediate))
  950. 00110001 dddd0000 aaaaaaaa aaaaaaaa 00110001 11000000 bbbbbbbb bbbbbbbb 00110101 11001100 aaaaaaaa aaaaaaaa 00111100 11001100 cccccccc cccccccc 00110100 11001100 00000000 00000001 00000111 11010000 00000000 00000000 00110100 11011101 00000000 00001100 00101110 11011100 00001101 00000000 00110101 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00110001 11000000 cccccccc cccccccc 00110101 11101110 00000000 00000100 01100110 00001100 00001110 00000000
  951.  
  952. for (%d(register) = %a:S16(immediate); %e(register) <= %b:S16(immediate); %c:S16(immediate))
  953. 00110001 dddd0000 aaaaaaaa aaaaaaaa 00110001 11000000 bbbbbbbb bbbbbbbb 00110101 11001100 aaaaaaaa aaaaaaaa 00111100 11001100 cccccccc cccccccc 00110100 11001100 00000000 00000001 00000111 11010000 00000000 00000000 00110100 11011101 00000000 00001100 00101110 11011100 00001101 00000000 00110101 11101110 00000000 00000100 01100110 00001101 00001110 00000000 00110001 11000000 cccccccc cccccccc 00110101 11101110 00000000 00000100 01100110 00001100 00001110 00000000
  954.  
  955. endfor %d(register)
  956. 01100010 11000000 00001110 00000000 00110100 11101110 00000000 00000100 00100100 dddddddd 00001100 00000000 01100010 11010000 00001110 00000000 00110100 11101110 00000000 00000100 00110101 11011101 00000000 00000001 00101111 11000000 00001101 00000000 00111010 11111100 00000000 00000000 00111000 11001101 00000000 00010000 01001101 00001111 00001100 00000000
  957.  
  958.  
  959.  
  960. //
  961. // Function instructions
  962. //
  963. call(%a(label))
  964. 00000111 11110000 00000000 00000000 00110111 11111111 00000000 00010100 00110101 11101000 00000000 00000100 01100110 00001111 00001110 00000000 01011000 00001111 aaaaaaaa aaaaaaaa
  965. # Calls %a. Overwrites the flag register. This instruction is a synonym for: counter flags add flags, flags, 20 sub sp, sp, 4 store_32 [sp], flags jmp %a
  966.  
  967. return
  968. 01100010 11110000 00001110 00000000 00110111 11101110 00000000 00000100 01001000 00001111 00001111 00000000
  969. # Returns from the last function call. Overwrites the flag register. This instruction is a synonym for: load_32 flags, [sp] add sp, sp, 4 jmp flags
  970.  
  971. */
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!