home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / math / classdoc / class.doc next >
Text File  |  1993-07-28  |  44KB  |  1,313 lines
  1.  Last changes made on 28-Sep-91             Version 0.99b
  2.  
  3.   ####  #      ####   #####  #####
  4.  #    # #     #    # #      #       The Clarke Assembler
  5.  #      #     ######  ####   ####
  6.  #    # #     #    #      #      #  (C)1991 Lutz Vieweg
  7.   ####  ##### #    # #####  #####
  8.  
  9.  ------------------    Manual   ------------------------
  10.  
  11. 0 Preface
  12. ---------
  13.  
  14. Please excuse linguistic mistakes in this text. English is not
  15. my native language. If you are not great at english, enjoy the
  16. easy words that are used, if your native language is english,
  17. think of what would be if you had to translate this text from
  18. german...
  19.  
  20. All the text following is up-to-date only at 27th of April 1991.
  21. The research goes on and on, there may be mistakes, the hardware
  22. may change.... etc.
  23.  
  24. This manual is written for people who have some experience in
  25. programming assembler on any computer. The HP48sx is not the
  26. right processor to learn assembler.
  27.  
  28. Of course there are NO (0.00, zero) warranties that there's one
  29. single true word in this text. Your Monitor may blow up while
  30. you read it, your grand-ma may die instantly having taken a spot
  31. on it, I cannot take responsibility on anything that happenes
  32. with this text.
  33.  
  34. 1.0 The Clarke-CPU Architecture
  35. -------------------------------
  36.  
  37. The Clarke processor is a child of the "Saturn" processor family.
  38. The Saturn processor family is a rather old one. As far as I know
  39. it was first used in HP's 71, later modified and customized for usage
  40. in the HP19B, 28C, 28S, 10B, 20S, 21S and finally 48sx.
  41.  
  42. 1.1 The Saturn-CPU's characteristics
  43. ------------------------------------
  44.  
  45. - CMOS technology (low power consumption)
  46. - 4 bit data-bus (memory organized in nibbles)
  47. - 20 bit adress-bus (able to adress 1 mega-nibble = 512kB unpaged)
  48. - Micro-code based instruction-set
  49. - 4 not-omni-purpose 64-bit data-registers (called a,b,c,d)
  50. - 5 64-bit "scratch"-registers (called r0,r1,r2,r3,r4)
  51. - 2 20-bit adress-registers (called d0,d1)
  52. - one 4-bit "field-pointer" register (called p)
  53. - one 20-bit program counter
  54. - 8-level return-adress stack, 20-bit each level
  55. - one 16-bit status-register (called st)
  56. - one 4-bit hardware-status-register (called hst)
  57. - one 16-bit I/O input-register (called in)
  58. - one 12-bit I/O output-register (called out)
  59. - a carry flag
  60. - operating in either HEX-mode or DEC-mode 
  61.  
  62. 1.2 Clarke-specific features
  63. ----------------------------
  64.  
  65. The Clarke processor runs up to 2000000 cycles per second. Actually,
  66. the processor-clock runs at a speed of about 1,96 MHz in the HP48sx.
  67. There has been some new instructions implemented in the processor's
  68. micro-code, compared to the 28s' CPU:
  69.  
  70. RSI
  71. MOVE.dd     #$xxx,a      (needs more nibbles than MOVE.dd #$xxx,c !)
  72. MOVE.fs|a   a|c,rx
  73. MOVE.fs|a   rx,a|c
  74. EXG.fs|a    a|c,rx
  75. ADD.fs|a    #$x,a|b|c|d
  76. SUB.fs|a    #$x,a|b|c|d
  77. LSR.fs|a    #1,a|b|c|d
  78. BCLR        #$x,a|c
  79. BSET        #$x,a|c
  80. BBC         #$x,a|c,label
  81. BBS         #$x,a|c,label
  82. JMP         (a)
  83. JMP         a|c
  84. move.a      pc,a|c
  85. exg.a       a|c,pc
  86. BUSCD
  87.  
  88. 1.3 Register usage
  89. ------------------
  90.  
  91. The data-registers are the ones that are used to hold values,
  92. do arithmetics on them or move them elsewhere. There is some
  93. kind of hierarchy between the four registers, because it is not
  94. possible to do the same instructions on each of them as it
  95. is at the 680xx-family's data-registers. From "good" to "bad"
  96. this hierarchy is c,a,b,d. There are a lot of adressing modes
  97. available only to the c or a register...
  98.  
  99. There are no differences in the way the processor supports
  100. each of the five "scratch"-registers. I set the quotation marks
  101. because these registers a very important for machine-language
  102. programmers even if they are supposed to hold "scratch" due to
  103. their name.
  104.  
  105. The two adress-registers are also equivalent, they are used to
  106. hold the adress of any location you want to access in the
  107. memory. Note that there is no "absolute" adressing possibility
  108. if want to move data around the memory.
  109.  
  110. The p register is not found similar on other machines. The normal
  111. usage of this register will be clear if you look at the "size
  112. extensions" chapter. But you can use this register also to hold
  113. one nibble of any kind of data. There are some strange adressing
  114. modes using this register. Because of it's meaning to the
  115. move.dd #expr,a.p|c.p instruction it is usually reset to zero
  116. after it has been changed and used.
  117.  
  118. The program-counter does not need to be discussed here. It just
  119. holds the adress were execution takes place actually.
  120.  
  121. The stack is much to small!!!! I really don't know how people
  122. can wish to save sillicium by sizing the stack to 8*20 bit.
  123. You'll have to place your own software-handled stack into memory
  124. when you wish to run complex machine-language programs.
  125.  
  126. The status register consists of 16 bit, which are used by the
  127. operating-system to hold important flags.
  128.  
  129. The hardware-status-register consists of four bit, having the
  130. following meanings:
  131. Bit 0  XM  Module missing (set by opcode $00, "empty memory")
  132. Bit 1  SB  Sticky bit (used as some sort of carry for shifting operations)
  133. Bit 2  SR  Service request (set if an I/O device needs "service")
  134. Bit 3  MP  Module pulled (really don't know the sense of this bit yet)
  135.  
  136. The input and output registers are used to transfer data from and
  137. to "devices" that are connected "daisy-chained" to the I/O bus.
  138. I guess HP has decided to keep this chain rather short, at the
  139. HP48sx I know only two devices accessed via I/O registers
  140. (piezo-beeper and keyboard), and they are using memory-register
  141. based I/O in the 48sx as it is done in most computers...
  142.  
  143. The carry-flag is the only conventional flag that exist in the Clarke
  144. CPU. It is used as on any other processor I know...
  145.  
  146.  
  147. 2.0 The CLASS Assembler's Mnemonics
  148. -----------------------------------
  149.  
  150. The mnemonics used by the CLASS-Assembler do not equal those published
  151. by HP in the IDS-manual. HP's mnemonics were a real horror to every
  152. guy who had programmed machine-language once before. I decided to
  153. use mnemonics that are similar to the ones used by the 680xx-family 
  154. Assemblers. This is not the same as the BABEL command-set used by
  155. some former assemblers, but I did not like to use this one because
  156. I think it is rather inconsequent structured. You may define macros
  157. to make BABEL source-codes processable CLASS.
  158.  
  159. A typical CLASS source-line looks like this:
  160.  
  161. label     mnemonic.size  parameter,parameter,parameter  ; comment
  162.  
  163. where label is a typical assembler-label which can be of any lenght
  164. up to 32767 bytes. Of course, the label should not be equal to any
  165. register- or other special name.
  166.  
  167. Mnemonic is just the command that should be translated into machine-code,
  168. with respect to the following size and/or parameters.
  169.  
  170. The size plays a very important role at the Clarke-processors machine
  171. language. There are a lot of possible sizes available, but they are
  172. of course not available to any opcode/adressing mode combination.
  173.  
  174. 2.1 Size extensions:
  175. --------------------
  176.  
  177. The great variety of possible size-extensions seems confusing and
  178. often useless. But remember, the Saturn-architecture was developed
  179. to laborate with 64-Bit BCD encoded floating-point-values, and
  180. therefore the size-extensions really make sense.
  181.  
  182. .1, .2, .3, .... .16 
  183. A size extension that consists of a decimal number in the range from 
  184. one to sixteen gives just the number of nibbles to be processed by
  185. the opcode. There are only a few commands that can handle one to
  186. sixteen nibbles, but this size extension is also used by some
  187. pseudo-opcodes described later.
  188. This size extension type will be abbreviated '.dd' in the following.
  189.  
  190. .a 
  191. One of the most used size-extension is .a, due to its meaning for the
  192. adress-handling. This extension is available to many commands. It
  193. defines the size to be processed to 20 bits (5 nibbles).
  194.  
  195. .p
  196. The .p extension tells the command to process the nibble pointed to by
  197. the p register, therefore accessing one nibble only.
  198.  
  199. .wp
  200. This extension tells the command to access the nibbles 0 to p of the
  201. specified register(s).
  202.  
  203. .xs
  204. Accesses the exponent sign: Nibble #2 of the registers.
  205.  
  206. .x
  207. Accesses the whole exponent: Three nibbles,  nibble 0 to nibble 2 of the
  208. registers.
  209.  
  210. .s
  211. Accesses the sign: Nibble 15 of the registers
  212.  
  213. .m
  214. Accesses the mantissa: 12 nibbles, nibble 3 to nibble 14 of the registers.
  215.  
  216. .b
  217. Accesses one byte: 2 nibbles, nibble 0 to nibble 1 of the registers.
  218. These to nibbles are used to hold the exponent (without the exponent
  219. sign).
  220.  
  221. .w
  222. Acesses one complete register or floating-point value: 16 nibbles,
  223. nibble 0 to nibble 15 of the registers.
  224.  
  225. If you access the memory by using one of the adress-registers, the
  226. specified size does not affect the location in memory.
  227.    MOVE.s   (d0),c
  228.    MOVE.xs  c,(d0)
  229. do both access the same adress in memory, but they use different
  230. nibbles of the c register.
  231.  
  232. In most cases, CLASS will accept the following equivalents:
  233. .2  = .b
  234. .3  = .x
  235. .4  = .as
  236. .5  = .a
  237. .16 = .w
  238.  
  239. 2.2 Size extension graphical summary:
  240. -------------------------------------
  241.      
  242. Assuming register p to consist the value 9
  243.  
  244. --------- Nibble of register ------------------
  245. 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00     Size-extension
  246. .. .. .. .. .. .. .. .. .. .. .. ** ** ** ** **     .a
  247. .. .. .. .. .. .. ** .. .. .. .. .. .. .. .. ..     .p
  248. .. .. .. .. .. .. ** ** ** ** ** ** ** ** ** **     .wp
  249. .. .. .. .. .. .. .. .. .. .. .. .. .. ** .. ..     .xs
  250. .. .. .. .. .. .. .. .. .. .. .. .. .. ** ** **     .x
  251. ** .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..     .s
  252. .. ** ** ** ** ** ** ** ** ** ** ** ** .. .. ..     .m
  253. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ** **     .b
  254. ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **     .w
  255. The following entries are only valid for the
  256.   MOVE.dd  #xxx,a.p|c.p
  257. command, still assuming p to be 9
  258. .. .. .. .. .. .. ** .. .. .. .. .. .. .. .. ..     .1
  259. .. .. .. .. .. ** ** .. .. .. .. .. .. .. .. ..     .2
  260. .. .. .. .. ** ** ** .. .. .. .. .. .. .. .. ..     .3
  261. .. .. .. ** ** ** ** .. .. .. .. .. .. .. .. ..     .4
  262. .. .. ** ** ** ** ** .. .. .. .. .. .. .. .. ..     .5
  263. .. ** ** ** ** ** ** .. .. .. .. .. .. .. .. ..     .6
  264. ** ** ** ** ** ** ** .. .. .. .. .. .. .. .. ..     .7
  265. ** ** ** ** ** ** ** .. .. .. .. .. .. .. .. **     .8
  266. ** ** ** ** ** ** ** .. .. .. .. .. .. .. ** **     .9
  267. ** ** ** ** ** ** ** .. .. .. .. .. .. ** ** **     .10
  268. ** ** ** ** ** ** ** .. .. .. .. .. ** ** ** **     .11
  269. ** ** ** ** ** ** ** .. .. .. .. ** ** ** ** **     .12
  270. ** ** ** ** ** ** ** .. .. .. ** ** ** ** ** **     .13
  271. ** ** ** ** ** ** ** .. .. ** ** ** ** ** ** **     .14
  272. ** ** ** ** ** ** ** .. ** ** ** ** ** ** ** **     .15
  273. ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **     .16
  274.  
  275. 2.3 Parameters
  276. --------------
  277.  
  278. The Clarke-processors commands use up to three parameters. The
  279. following types of parameters are supported by CLASS:
  280.  
  281. label    A string that defines the name of a label, a numerical
  282.          or one that is a offset to the object-code's begin. Example:
  283.          JMP label
  284.  
  285. #expr    An expression that is calculated while assembling. 
  286.          See also chapter 2.4            Example:
  287.          BSET #expr,st
  288.  
  289. a|b|c|d  One of the four data-registers a,b,c and d.
  290.          The '|' sign is used as a logical OR in the following
  291.          Example:
  292.          MOVE a,c
  293.  
  294. c.dd     The nibble pointed to by dd (decimal digit 0 to 15) in c register
  295.  
  296. c.p      The nibbles from the one p points to higher ones in c register
  297. a.p      The nibbles from the one p points to higher ones in a register
  298.  
  299. rx       One of the five scratch-registers r0,r1,r2,r3 and r4
  300.  
  301. p        The p register
  302.  
  303. st       The status-register
  304.  
  305. hst      The harware-status-register
  306.  
  307. in       The I/O input-register
  308.  
  309. out      The I/O output-register
  310.  
  311. 2.4 Expression evaluation
  312. -------------------------
  313.  
  314. Expressions may consist of labels, absolute values, operators
  315. and parentheses. Expressions are evaluated without any kind
  316. of hierarchy, you have to set parentheses if required. This behaviour
  317. may change in future versions of CLASS.
  318. Numerical labels and those who include an offset to the object's
  319. begin are treated the same in the actual version. This may also
  320. change in future.
  321.  
  322. 2.4.1 Operators
  323. ---------------
  324.  
  325. Actually, there are only a few operators supported:
  326. +   Addition
  327. -   Subtraction / negative sign
  328. *   Multiplication
  329. /   Division
  330. |   OR
  331. &   AND
  332. \   XOR
  333.  
  334. 2.4.2 Absolute values
  335. ---------------------
  336.  
  337. Decimal numbers begin with a number from 0 to 9.        1234
  338. Hexadecimal numbers are prefixed with an dollar sign.  $12ab 
  339. Binary numbers are prefixed with a per-cent sign.      %01101
  340. ASCII-codes are written between quotation marks.       "xy12"
  341.       
  342. 2.5 Adressing modes
  343. -------------------
  344.  
  345. The following is a complete (?hope so?) list of the available
  346. adressing modes:
  347.  
  348. #expr          Absolute value
  349. label          Absolute adress
  350. a|b|c|d        Data-register direct
  351. (a)            Data-register indirect (used in JMP (a) only)
  352. d0|d1          Adress-register direct
  353. (d0)|(d1)      Adress-register indirect
  354. r0|r1|r2|r3|r4 Scratch-register direct
  355. p              P-register direct
  356. st             Status-register direct
  357. hst            Hardware-status-register direct
  358. in             I/O input-register direct
  359. out            I/O output-register direct
  360. c.dd           Data-register c with special nibble-pointer
  361. a|c.p          Data-register from nibble pointed to by p register upwards
  362.  
  363. 2.6 Mnemonic summary
  364. --------------------
  365.  
  366. Many of the mnemonics listed here are sharing the format
  367.          mnemonic.size source,dest
  368. Notice that this is similar to the 680xx family's assembly format,
  369. and the opposite of Intel's one.
  370.  
  371. The following abbreviations will be used:
  372. fs  Field selctor. One of the extensions .p, .wp, .xs, .x, .s, .m, .b, .w
  373. rx  One of the five scratch-registers r0,r1,r2,r3,r4
  374.  
  375. Notice that commands that use the .a size-extension need less nibbles
  376. to be coded in most cases.
  377.  
  378. 2.6.1 Data transfer instructions
  379. --------------------------------
  380.  
  381. MOVE
  382. ----
  383.  
  384. The most used mnemonic at all is the move-command. There are a lot of
  385. adressing modes available, but they are not very similar to the
  386. adressing modes used by other processors. In fact, there are
  387. missing very potent ones like index'ed adressing.
  388.  
  389. Available:
  390.  
  391. move.fs|a    b|c    ,a
  392. move.fs|a    a|c    ,b
  393. move.fs|a    a|b|d  ,c
  394. move.fs|a    c      ,d
  395.  
  396. move.3       c      ,st         ; only 12 of the 16 st-bits are affected!
  397. move.3       st     ,c
  398.  
  399. move.a|4     a|c    ,d0|d1      ; move.a|4 d0|d1,a|c does not exist!!!
  400.                                 ; use exg.a|4 a|c,d0|d1 if required
  401. move.fs|a|dd a|c    ,(d0|d1)    ; .a and .b are needing less nibbles
  402. move.fs|a|dd (d0|d1),a|c        ; .a and .b are needing less nibbles
  403.  
  404. move.w       a|c    ,rx
  405. move.w       rx     ,a|c
  406. move.fs|a    a|c    ,rx         ; these two need more nibbles than the
  407. move.fs|a    rx     ,a|c        ; previous - they were implemented later
  408.  
  409. move.4       in     ,a|c        ; this instruction fails if it is executed
  410.                                 ; on an odd adress. A bug in the microcode
  411. move.3       c      ,out
  412. move.s       c      ,out        ; out high-nibble affected
  413.  
  414. move.1       p      ,c.dd
  415. move.1       c.dd   ,p
  416.  
  417. move.1       #expr  ,p
  418.  
  419. move.a       #expr  ,d0|d1
  420. move.ao      #expr  ,d0|d1      ; read "RELTAB" description
  421. move.as      #expr  ,d0|d1
  422. move.b       #expr  ,d0|d1
  423.  
  424. move.dd      #expr  ,a.p|c.p    ; this instruction is used that often, I
  425.                                 ; decided to allow 'a' or 'c' as destination
  426.                                 ; take care of the contents of p !
  427. move.ao      #expr  ,a.p|c.p    ; read "RELTAB" description
  428.  
  429. move.a       pc     ,a|c
  430.  
  431. EXG
  432. ---
  433.  
  434. EXG exchanges the contents of two registers. It makes is no difference
  435. which register is defined first:
  436. exg.w c,r0  =  exg.w r0,c   and so on...
  437.  
  438. EXG is a very usual instruction on the Clarke processor, it allows to
  439. use the scratch-registers as quick-accessable data storage and
  440. it is the only way to move an adressa out of an adress-register.
  441.  
  442. Available:
  443.  
  444. exg.w        c|a    ,rx
  445. exg.fs|a     c|a    ,rx         ; this one needs more nibbles than the
  446.                                 ; previous - it were implemented later
  447.  
  448. exg.a        c|a    ,d0|d1
  449.  
  450. exg.fs|a     a|b|c  ,a|b|c
  451. exg.fs|a     c      ,d
  452.  
  453. exg.1        p      ,c.dd
  454.  
  455. exg.a        a|c    ,pc
  456.  
  457. PUSH
  458. ----
  459.  
  460. PUSH "pushes" a 20-bit value from register c onto stack.
  461.  
  462. Available:
  463.  
  464. push
  465.  
  466. POP
  467. ---
  468.  
  469. POP transfers the top 20-bit of the stack into the lower 20-bit of
  470. register c.
  471.  
  472. Available:
  473.  
  474. pop
  475.  
  476.  
  477. 2.6.2 Arithmetic instructions
  478. -----------------------------
  479.  
  480. ADD
  481. ---
  482.  
  483. ADD is just what it is on every micro-processor: It adds two values
  484. and stores the result in a register. There are powerful increment
  485. instructions similar to the ADDQ instruction in the 680xx family,
  486. but I decided to use the same mnemonic, add, for them.
  487.  
  488. Available:
  489.  
  490. add.a        #expr  ,d0|d1   ; expr must be >=1 and <=16
  491.  
  492. add.fs|a     #expr  ,a|b|c|d ; expr must be >=1 and <=16. In fact,
  493.                              ; only the .b, .x, .a, .m and .w extension
  494.                              ; work properly on this instruction.
  495.  
  496. add.fs|a     a|b|c  ,a|b|c   ; adding one register on itself is allowed!
  497. add.fs|a     c|d    ,d|c     ; It's then just a shift left one bit!
  498.  
  499. add.a        p+1    ,c       ; This one is always done in hex-mode
  500.                              ; Wonderful to combine with .wp size extension
  501. SUB
  502. ---
  503.  
  504. SUB subtracts the first parameter from the second and stores the
  505. result in the register that has to be specified as the second parameter.
  506.  
  507. Available:
  508.  
  509. sub.fs|a     a|b|c  ,a|b|c
  510. sub.fs|a     c|d    ,d|c
  511.  
  512. sub.a        #expr  ,d0|d1      ; expr must be >=1 and <=16
  513.  
  514. add.fs|a     #expr  ,a|b|c|d ; expr must be >=1 and <=16. In fact,
  515.                              ; only the .b, .x, .a, .m and .w extension
  516.                              ; work properly on this instruction.
  517.  
  518. SUBR
  519. ----
  520.  
  521. SUBR is not available on the 680xx-family. It subtracts the second
  522. parameter from the first and stores the result in the register that
  523. has to be specified as the second parameter.
  524.  
  525. Available:
  526.  
  527. subr.fs|a    b      ,a
  528. subr.fs|a    c      ,b
  529. subr.fs|a    a      ,c
  530. subr.fs|a    c      ,d
  531.  
  532. INC
  533. ---
  534.  
  535. INC increases a specified register by one.
  536.  
  537. Available:
  538.  
  539. inc.fs|a     a|b|c|d
  540.  
  541. inc.1        p
  542.  
  543. inc.a        d0|d1              ; identical to add.a #1,d0|d1
  544.  
  545. DEC
  546. ---
  547.  
  548. DEC decreases a specified register by one.
  549.  
  550. Available:
  551.  
  552. dec.fs|a     a|b|c|d
  553.  
  554. dec.1        p
  555.  
  556. dec.a        d0|d1              ; identical to sub.a #1,d0|d1
  557.  
  558. CLR
  559. ---
  560.  
  561. CLR stores zero into a register.
  562.  
  563. Available:
  564.  
  565. clr.3        st           ; only the lower 12 bits are cleared!
  566.  
  567. clr.fs|a     a|b|c|d
  568.  
  569. clr.1        #expr  ,hst  ; the bits set in expr are cleared in hst
  570.  
  571. NEG
  572. ---
  573.  
  574. NEG converts a registers value into it's 2's complement.
  575.  
  576. Available:
  577.  
  578. neg.fs|a     a|b|c|d
  579.  
  580. NOT
  581. ---
  582.  
  583. NOT inverts all the bits in a register's field.
  584.  
  585. Available:
  586.  
  587. not.fs|a     a|b|c|d
  588.  
  589.  
  590. 2.6.3 Binary-arithmetic instructions
  591. ------------------------------------
  592.  
  593. OR
  594. --
  595.  
  596. OR bitwise "ors" two registers and stores the result in the second one.
  597.  
  598. Available:
  599.  
  600. or.fs|a      a|b|c  ,a|b|c
  601. or.fs|a      c|d    ,d|c
  602.  
  603. AND
  604. ---
  605.  
  606. AND bitwise "ands" two registers and stores the result in the second one.
  607.  
  608. Available:
  609.  
  610. and.fs|a     a|b|c  ,a|b|c
  611. and.fs|a     c|d    ,d|c
  612.  
  613. LSL
  614. ---
  615.  
  616. LSL shifts the bits in a register to the left, setting the rightmost
  617. bit to zero after each shift.
  618.  
  619. Available:
  620.  
  621. lsl.fs|a     #4     ,a|b|c|d  ; a one-nibble shift in fact
  622. lsl.fs|a     #1     ,a|b|c|d  ; is identical to add.fs|a a,a|b,b|c,c|d,d
  623.  
  624. LSR
  625. ---
  626.  
  627. LSR shifts the bits in a register to the right, setting the leftmost
  628. bit to zero after each shift.
  629.  
  630. Available:
  631.  
  632. lsr.fs|a     #4     ,a|b|c|d  ; a one-nibble shift in fact
  633. lsr.w        #1     ,a|b|c|d
  634. lsr.fs|a     #1     ,a|b|c|d  ; needs more nibbles than the
  635.                               ; previous one - later implemented
  636.  
  637. ROL
  638. ---
  639.  
  640. ROL rotates the bits in a register to the left, setting the rightmost
  641. bit to the value shifted out 
  642.  
  643. Available:
  644.  
  645. rol.w        #4     ,a|b|c|d  ; that's all - sorry
  646.  
  647. ROR
  648. ---
  649.  
  650. ROR rotates the bits in a register to the right, setting the leftmost
  651. bit to the value shifted out 
  652.  
  653. Available:
  654.  
  655. ror.w        #4     ,a|b|c|d  ; that's all - sorry
  656.  
  657. BSET
  658. ----
  659.  
  660. BSET sets a specified bit in a register. It is not possible to use
  661. this instruction on a bit-number higher than 15. Bit numbers always
  662. counts from 0, the LSB of the register. There's no size-extension.
  663.  
  664. Available:
  665.  
  666. bset         #expr  ,a|c      ; expr must be >=0 and <=15
  667.  
  668. bset         #expr  ,st       ; expr must be >=0 and <=15
  669.  
  670. BCLR
  671. ----
  672.  
  673. BCLR cleares a specified bit in a register. It is not possible to use
  674. this instruction on a bit-number higher than 15. Bit numbers always
  675. counts from 0, the LSB of the register. There's no size-extension.
  676.  
  677. Available:
  678.  
  679. bclr         #expr  ,a|c      ; expr must be >=0 and <=15
  680.  
  681. bclr         #expr  ,st       ; expr must be >=0 and <=15
  682.  
  683. 2.6.4 Conditional branches
  684. --------------------------
  685.  
  686. The instructions that affect the program counter do not differ much
  687. from those found on other processors. But there are two anomalies:
  688. Every conditional branch can be also a conditional return-from-
  689. subroutine by setting the branch-offset to zero. 
  690. Due to the lack of flags, the conditional branches include the
  691. neccesary test operations.
  692.  
  693. The following tests are supported:
  694. eq  =   equal
  695. ne  !=  not equal
  696. lt  <   lower than 
  697. le  <=  lower or equal
  698. gt  >   greater than
  699. gs  >=  greater or equal
  700.  
  701. There are four other, special tests:
  702.  
  703. cc      carry clear      The branch is taken if the carry flag is clear
  704. cs      carry set        The branch is taken if the carry flag is set
  705. bc      bit clear        The branch is taken if the specified bit is 0
  706. bs      bit set          The branch is taken if the specified bit is 1
  707.  
  708. The label that defines the adress to jump to when the branch is taken,
  709. must be within a range of -128 to 127 around the adress the offset is
  710. defined.
  711.  
  712. Available:
  713.  
  714. bcc          label
  715. bcs          label
  716. rtcc                           ; return-if-carry-clear ...
  717. rtcs
  718.  
  719. beq.fs|a     a|b|c|d,0,label   ; branch is taken if register is zero
  720. bne.fs|a     a|b|c|d,0,label   ; branch is taken if register is not zero
  721.  
  722. beq.fs|a     a|b|c,a|b|c,label ; branch is taken if registers are equal
  723. beq.fs|a     c|d,d|c,label
  724.  
  725. rteq.fs|a    a|b|c|d,0         ; return if register is zero
  726. rtne.fs|a    a|b|c|d,0
  727.  
  728. blt.fs|a     a|b|c,a|b|c,label ; branch is taken if first register is lower
  729. blt.fs|a     c|d,d|c,label     ; than second one
  730.  
  731. ble.fs|a     a|b|c,a|b|c,label 
  732. ble.fs|a     c|d,d|c,label     
  733.  
  734. bgt.fs|a     a|b|c,a|b|c,label 
  735. bgt.fs|a     c|d,d|c,label     
  736.  
  737. bge.fs|a     a|b|c,a|b|c,label 
  738. bge.fs|a     c|d,d|c,label     
  739.  
  740. rtlt.fs|a    a|b|c,a|b|c
  741. rtlt.fs|a    c|d,d|c
  742.  
  743. rtgt.fs|a    a|b|c,a|b|c
  744. rtgt.fs|a    c|d,d|c
  745.  
  746. rtle.fs|a    a|b|c,a|b|c
  747. rtle.fs|a    c|d,d|c
  748.  
  749. rtge.fs|a    a|b|c,a|b|c
  750. rtge.fs|a    c|d,d|c
  751.  
  752. beq.1        #expr,hst,label ; branch is taken if hst AND expr is zero
  753. rteq.1       #expr,hst
  754.  
  755. beq.1        #expr,p,label  ; branch is taken if expr is equal to contents
  756. rteq.1       #expr,p        ; of p register
  757.  
  758. bne.1        #expr,p,label
  759. rtne.1       #expr,p
  760.  
  761. bbc          #expr,st,label ; branch is taken if specified bit in st is clear
  762. rtbc         #expr,st
  763.  
  764. bbs          #expr,st,label ; branch is taken if specified bit in st is set
  765. rtbs         #expr,st
  766.  
  767. bbc          #expr,a|c,label
  768. rtbc         #expr,a|c
  769.  
  770. bbs          #expr,a|c,label
  771. rtbs         #expr,a|c
  772.  
  773. 2.6.5 Unconditional branches and other pc manipulation
  774. ------------------------------------------------------
  775.  
  776. Please notice: Use relative branches if possible;
  777.                use always the "smallest" jump, that reaches
  778.                the desired adress.
  779.  
  780. Available:
  781.  
  782. bra.3        label   ; jumps relative (range: -2048 to +2047)
  783. bra.4        label   ; jumps relative (range: -32768 to 32767)
  784.  
  785. bsr.3        label   ; calls subroutine (range: -2048 to +2047)
  786. bsr.4        label   ; calls subroutine (range: -32768 to +32767)
  787.  
  788. jmp          label   ; jumps to absolute 20-bit adressa
  789. jsr          label   ; calls subroutine at absolute 20-bit adressa
  790.  
  791. jmp          a|c     ; jumps to the location pointed to by the lower
  792.                      ; 20 bits of the specified register
  793.  
  794. jmp          (a)     ; jump to the adress that is defined at the
  795.                      ; memory location pointed to by the lower 20 bits
  796.                      ; of the specified register
  797.  
  798. rtnsxm               ; return and set XM-flag in hst. Used to catch
  799.                      ; "jumps into the desert" (opcode $00)
  800. rtn                  ; simply return from subroutine
  801. rtncc                ; return and clear carry
  802. rtnsc                ; return and set carry
  803.  
  804. rsi                  ; return from system interrupt. Not fully explored yet
  805.  
  806. 2.6.6 Miscellaneous instructions
  807. --------------------------------
  808.  
  809. sethex       ; sets the processor into HEX-Mode
  810. setdec       ; sets the processor into DEC-Mode
  811.  
  812. Not fully explored yet.
  813. I do not know exactly how the mode affects the processors work.
  814.  
  815. nop4         ; an artifical 4-nibble-nop, in fact a senseless branch
  816.  
  817. uncnfg       ; unconfigures all chips (?) and transfers the lower
  818.              ; 20 bits of register c into each chip controller's
  819.              ; data pointer. Not fully explored yet.
  820. config       ; sends the lower 20-bits of register c to the chip
  821.              ; which has daisy chain input high and config flag low
  822.              ; Not fully explored yet
  823. c=id         ; identifies chip: transfers the ID of the chip which has
  824.              ; daisy chain input high and config flag low to the
  825.              ; lower 20 bits of register c
  826.              ; Not fully explored yet
  827. shutdn       ; sends bus-shut-down command and stops CPU-Clock
  828. inton        ; enables some sort of interrupt (from keyboard?)
  829. intoff       ; disables some sort of interrupt (from keyboard?)
  830. reset        ; sends system-bus-reset command, resets chips. Not fully...
  831. buscc        ; sends system-bus command "C". Not fully...
  832. buscd        ; sends system-bus command "D"? Not fully...
  833. sreq?        ; if any chip on bus needs service, SR-bit in hst is set,
  834.              ; and the "device-identifier" is latched to the lowest
  835.              ; nibble of register c
  836.  
  837.  
  838. 3.0 The CLASS Assembler's pseudo-ops
  839. ------------------------------------
  840.  
  841. There are a lot of so called "pseudo-opcodes" supported - instructions
  842. that are not translated into bits instructing the processor to do something.
  843.  
  844. 3.1 Include files
  845. -----------------
  846.  
  847. Every serious assembler supports include-files. You may type a line
  848. into your source-code, that has the "include" command in the mnemonic
  849. field and a filename as a parameter. This file will be inserted
  850. into the source while assembly. An include-file (which is, of course
  851. a normal source-file also) may include other files. There's no nesting
  852. limit but your stack's size.
  853. Examples:
  854.              include   "DH0:blub.a"
  855.              include   trash.a
  856. Notice: Every include-file will increase the number of lines to assemble
  857. (sounds simple..?)
  858.  
  859. 3.2 Constants
  860. -------------
  861.  
  862. Constants are nibbles created by the assembler that are not executable
  863. code.
  864.  
  865. 3.2.1 Nibble-by-nibble constants
  866. --------------------------------
  867.  
  868. With the "dc", "dcr" and "dcg" pseudo-ops you can place any kind of data
  869. into your object-file. The format is:
  870.           dc.dd   value, value, value, ... 
  871.           dcr.dd  value, value, value, ... 
  872.           dcg.dd  value, value, value, ... 
  873. dd defines the constant's size. 
  874. "dc" puts the values from high- to low-nibble into memory, as it is done
  875. by the 680xx family for example.
  876. "dcr" puts the values from low- to high-nibble into memory, this is how
  877. the Clarke-processor does it. Example:
  878.  
  879. start       move.a #data,d0
  880.             move.a (d0),c
  881.             add.a  #5,d0
  882.             move.a (d0),a
  883.             rtn
  884. data        dcr.5  $12345
  885.             dc.5   $12345
  886.  
  887. After calling this routine, register c will hold $12345 while register a
  888. contents $54321.
  889.  
  890. "dcg" is used to define graphic-data for the HP48sx bit-plane format.
  891. Not only the order of the nibbles is reversed, the bits itself are
  892. also exchanged. You can shift graphic-data pixel-wise by just shifting
  893. the register that holds the data. Notice that the bit-plane of the HP48sx
  894. is organized byte-wise.
  895.  
  896. 3.2.2 Text-Constants
  897. --------------------
  898.  
  899. With the "text" pseudo-ob you can place ASCII-codes into your object file.
  900. There's another pseudo-ob, "textr", which is used to reverse the nibbles
  901. of each ASCII. Format:
  902.          text    "The quick brown fox jumps over the lazy dog"
  903.          textr   "The quick brown fox jumps over the lazy dog"
  904.  
  905. 3.3 The EQU instruction
  906. -----------------------
  907.  
  908. Use the "equ" pseudo-ob to define the value of a label to be created.
  909. Format:
  910. label     equ     expr
  911. References between label-definitions are solved completely. The following
  912. example will cause no trouble:
  913. jim       equ     bob+jeff-7
  914. bob       equ     jeff/2
  915. jeff      equ     6
  916. The following example will cause trouble:
  917. jim       equ     bob+jeff-7
  918. bob       equ     jeff/2
  919. jeff      equ     jim
  920.  
  921. >ERROR: Unable to solve reference between following labels:
  922. >jim
  923. >bob
  924. >jeff
  925.  
  926. 3.4 Macros
  927. ----------
  928.  
  929. To define a macro, use this syntax:
  930.  
  931. name         macro     para1,para2,para3,para4
  932. ....
  933. ....
  934.              endmac
  935.  
  936. Notice: - You can use any string to define a parameter. It's a good idea
  937.           to choose a string that never occures in normal source-code.
  938.         - The endmac statement must be the only word in the terminating
  939.           line.
  940.         - You cannot nest macros.
  941.         - Macros must be defined BEFORE they are used in the source.
  942.         - Use "?cnt?" to place a unique number for each macro in the
  943.           resulting source
  944.         - The number of possible parameters is limited to 4
  945.         - The total lenght of source-text in a macro is limited to
  946.           32767 characters
  947.  
  948. Examples:
  949.  
  950. rpl         macro    value        
  951.             dcr.5    value
  952.             endmac
  953.  
  954. absadr      macro    lbl,reg
  955.             bsr      absadr?cnt?
  956. absadr?cnt? pop
  957.             move.a   #lbl-absadr?cnt?,a
  958.             add.a    a,c
  959.             move.a   c,reg
  960.             endmac
  961.                              ; what follows is an example how the macros
  962.                              ; are called
  963.             rpl      $02d9d
  964.             absadr   data,d0
  965.             
  966.             move.3   #$123,c
  967.             move.3   c,(d0)
  968.                              ; just an example ... has no meaning
  969. data        text     "-----------"
  970.  
  971. The "absadr"-macro would look like this after expanding:
  972.             bsr      absadr1
  973. absadr1     pop
  974.             move.a   #data-absadr1,a
  975.             add.a    a,c
  976.             move.a   c,d0
  977.  
  978. 3.5 The relocation-table
  979. ------------------------
  980.  
  981. To write programs that are relocated before execution I implemented a
  982. pseudo-ob called "RELTAB". Use this pseudo to insert a table of the
  983. following format into your code:
  984.  
  985. $XXXXX   20-Bit-Offset from PGM's base, where to find first adress to reloc
  986. $XXXXX   2. adress...
  987. ...      3. 4. 5. ... adresses
  988. ...
  989. $00000   A terminating zero-adress to signal list's end
  990.  
  991. Entries in this table are made the following way:
  992. Whenever CLASS faces a valid instruction with a size-extension that is ".ao",
  993. it calculates the offset from the begin of the program to the adress
  994. where to find the 20-Bit-adress that is specified within the instruction.
  995. This adress is held in a variable until the RELTAB instruction is found.
  996. Then all the adresses collected becomes entries in the relocation table.
  997. The variables are cleared, and the game starts over.
  998. You may have more than one relocation-table in one program. But be sure
  999. to use the right ones for relocation during execution then.
  1000. A sample relocation- and re-relocation-routine comes within the CLASS package.
  1001. It'll fit your needs on a HP48sx.
  1002. Note: A RELTAB command only cares about the adressas that have been specified
  1003.       in the source above.
  1004.       Be sure to avoid a 48sx-garbage-collection between relocation and
  1005.       re-relocation.
  1006.       If you fail to re-relocate a program after execution, your system
  1007.       may crash the next time you call the program. Avoid unwanted
  1008.       interrupts!!!
  1009.  
  1010. 4.0 Local labels
  1011. ----------------
  1012.  
  1013. The CLASS assembler supports local labels in a very easy way, to explain
  1014. how to use them I will simply explain what CLASS does:
  1015.  
  1016. Whenever CLASS finds a label that does end with an "." character, it
  1017. assumes this label to be global. It stores the name of such a label
  1018. in special variable.
  1019. Whenever CLASS encounters a label with an "." as FIRST character, it
  1020. takes the name of the last global label from the special variable,
  1021. apends the name of the local label (including the point) and adds
  1022. another point at the end of the total name.
  1023.  
  1024. This is the whole thing. Now look what you can do with it...
  1025.  
  1026. start      text   "the example starts here with a global label" 
  1027.            bra    .1        ; a first reference to a local label
  1028.            text   "just a filler"
  1029. later.                      ; a label that has been inserted later.
  1030.                             ; it is a global one, but it does not
  1031.                             ; affect the last-global-name variable
  1032.            text   "just a filler"
  1033. .1      
  1034.            text   "this would be the destination of the branch"
  1035. .jimbob 
  1036.            text   "local label names are normal strings..."
  1037. ende                     ; the end of the routine, a global label
  1038.            dc.5   start.1.  ;access local label from an outer point...
  1039. .1                            ; you can use ".1" as label name again...
  1040.            dc.5   later.    ; a reference to the later inserted label
  1041.            bra    .1        ; this jump goes to ende.1.
  1042.  
  1043. 5.0 Invocation
  1044. --------------
  1045.  
  1046. The invocation of the CLASS assembler depends on the
  1047. computer-type you use.
  1048.  
  1049. 5.1 Invoking CLASS on Commodore's AMIGA
  1050. ---------------------------------------
  1051.  
  1052. You have to invoke CLASS from a command-line interpreter. Use the
  1053. following format:
  1054.  
  1055. CLASS -a SOURCENAME [-o OBJECTNAME] [-i INCLUDE_DIR] [-ml maximal_lines]
  1056.       [-mm maximal_macros] [-ul] [-rn] [-mr maximal_reloctab_entries]
  1057.       [-s SYMBOL_FILE] 
  1058.  
  1059. Upper-case parameters have to be replaced by a string, lower-case ones
  1060. have to be replaced by a decimal number.
  1061. Parameters in parentheses are optional
  1062.  
  1063. -a   Defines the name of the source file
  1064. -o   Defines the name of the object file
  1065. -i   Defines the name of the include file directory (the actual path
  1066.      is searched also)
  1067. -s   Defines the name of an optinal symbol-file (e.g. for use with CLDIS)
  1068. -ml  Defines the maximal number of source-lines
  1069. -mm  Defines the maximal number of macro-definitions
  1070. -mr  Defines the maximal number of reloction-table-entries (view "RELTAB")
  1071. -ul  Enables listing of unused labels at the end of assembly
  1072. -rn  Enables nibble-swapping at end of assembly. Requiered if you use
  1073.      a "dumb" KERMIT-program that doesn't the swapping.        
  1074.  
  1075. 5.2 Invoking CLASS on Atari's ST
  1076. --------------------------------
  1077.  
  1078. After having started CLASS.TTP from either the desktop or any CLI
  1079. you can use the same set of options discussed under 5.1.
  1080.  
  1081. To hold screen after execution keep mouse-key pressed.
  1082.  
  1083. Please do not use external screen output accelerators like
  1084. NVDI, TurboST or QuickST for there may occur pixel-trash then.
  1085.  
  1086. 6.0 Bugs and future extensions
  1087. ------------------------------
  1088.  
  1089. This is a early release of CLASS. I'm sure there are bugs
  1090. in it. Please report any bug you find to me (adress: see below).
  1091. I'm also happy about any good idea for additional features.
  1092.  
  1093. 6.1 Known Bugs
  1094. --------------
  1095.  
  1096. - CLASS is not that fast. I have not optimized
  1097.   the code in any other way than saving programming-time now.
  1098. - CLASS is not able to handle expressions that exceed the 32 bits a
  1099.   68000 is able to hold in a register. There are only two instructions
  1100.   where this disadvantage can cause problems: move.dd #expr,c.p|a.p
  1101.   If you really need to use such an instruction with more than 8
  1102.   nibbles, you can replace it manually:
  1103.  
  1104.   move.16 #$0123456789abcdef,c.p
  1105.  
  1106.   can be replaced by:
  1107.  
  1108.   dc.1    $3,16-1
  1109.   dc.8    $fedcba98,$76543210
  1110.  
  1111.  
  1112.   move.16 #$0123456789abcdef,a.p
  1113.  
  1114.   can be replaced by:
  1115.  
  1116.   dc.4    $8082
  1117.   dc.1    16-1
  1118.   dc.8    $fedcba98,$76543210
  1119.  
  1120.   Maybe I'll find the motivation to process 64-bit-values later, but 
  1121.   I don't think it's that neccessary.
  1122.  
  1123. 6.2 New features to come
  1124. ------------------------
  1125.  
  1126. - More speed
  1127. - A more different bahavior of numeric and offset labels
  1128. - Conditional assembly
  1129. - More useful pseudo-ops
  1130.  
  1131. Since this program is not published the commercial way, I cannot
  1132. guarantee updates at all.
  1133.  
  1134. 7.0 Trademarks
  1135. --------------
  1136.  
  1137. Amiga      : Commodore-Amiga Inc., USA
  1138. Atari ST   : Atari 
  1139. HP48sx     : Hewlett Packard, USA
  1140.  
  1141. 8.0 Adress of the author
  1142. ------------------------
  1143.  
  1144. Please contact me via EMail.
  1145.  
  1146. UseNet : lv@muffel.hotb.sub.org
  1147. FidoNet: 2:247/30.20
  1148.  
  1149. If it seems VERY urgent, and you cannot use EMAIL, call
  1150. -49-69-5601966 (voice)
  1151.  
  1152. Appendices:
  1153. -----------
  1154.  
  1155. A. HP48sx Processor Performance - explored by L. Vieweg May 1991
  1156. ----------------------------------------------------------------
  1157.  
  1158. A.1.0 The cycle period
  1159. ----------------------
  1160.  
  1161. The HP48sx Clarke-processor clock runs at 1.96 MHz (in my machine).
  1162. About 25% of the processors speed is cut off when you enable the
  1163. BitPlane DMA. To run your processor at full speed, clear bit 3 at
  1164. $00100.
  1165.  
  1166. A.2.0 Instruction execution times
  1167. ---------------------------------
  1168.  
  1169. These are the execution times of the Clarke processor's
  1170. most used instructions. This list may be completed or revised later.
  1171. Notice: If there are fractional cycles given, calculate the total
  1172.         cycles first, then round the number (7.5 => 8 and so on...).
  1173.         The abbreviation "siz" means the total number of nibbles
  1174.         affected by an instruction (.s=1, .b=2, .x=3, .a=5, .w=16, ...)
  1175.         Refer to the CLASS-assembler's manual for further information.
  1176.  
  1177. Add one cycle for each odd adress the pc runs through. This will
  1178. cause some nasty effects when programming time-critical routines. 
  1179.  
  1180. Instruction      Source    Dest          Cycles 
  1181. -----------------------------------------------------------------
  1182. move.dd          #0        ,c.p          2.5+dd*1.5
  1183.  
  1184.                                               normal / access $00100-$0013f
  1185. move.dd          (d1)|(d0) ,c|a          21.5+dd*1.5 / 21+dd
  1186. move.fs          (d1)|(d0) ,c|a          21.5+siz*1.5 / 21+siz
  1187. move.b           (d1)|(d0) ,c|a          19          /17       
  1188. move.a           (d1)|(d0) ,c|a          23          /20       
  1189.                            
  1190. move.a           c|a       ,(d0)|(d1)    19
  1191. move.b           c|a       ,(d0)|(d1)    16
  1192. move.fs          c|a       ,(d0)|(d1)    20+siz
  1193. move.dd          c|a       ,(d0)|(d1)    20+siz
  1194.  
  1195. move.a           a         ,c            8
  1196. move.fs          a|b|c|d   ,a|b|c|d      4+siz
  1197.  
  1198. move.a           a|c       ,d0|d1        9
  1199. move.4           a|c       ,d0|d1        8
  1200.  
  1201. move.w           a|c       ,rx           20
  1202. move.w           rx        ,a|c          20
  1203.  
  1204. move.1           p         ,c.dd         8
  1205. move.1           c.dd      ,p            8
  1206.  
  1207. move.1           #expr     ,p            3
  1208.  
  1209. move.a           #expr     ,d0|d1        10
  1210. move.as          #expr     ,d0|d1        9
  1211. move.b           #expr     ,d0|d1        6
  1212.  
  1213. clr.fs           a|b|c|d                 4+siz
  1214. clr.a            a|b|c|d                 8
  1215.  
  1216. clr.1            #expr     ,hst          4
  1217.  
  1218. exg.w            c|a       ,rx           20
  1219. exg.a            c|a       ,d0|d1        9
  1220.  
  1221. exg.fs           a|b|c|d   ,a|b|c|d      4+siz
  1222. exg.a            a|b|c|d   ,a|b|c|d      8
  1223.  
  1224. exg.1            p         ,c.dd         8
  1225.  
  1226. push             pop                     18  (the two's total)
  1227.  
  1228. add.a            #expr     ,d0|d1        8
  1229.  
  1230. add.fs           a|b|c|d   ,a|b|c|d      4+siz
  1231. add.a            a|b|c|d   ,a|b|c|d      8
  1232.  
  1233. add.a            p+1       ,c            9
  1234.  
  1235. sub.fs           a|b|c|d   ,a|b|c|d      4+siz
  1236. sub.a            a|b|c|d   ,a|b|c|d      8
  1237. subr.fs          a|b|c|d   ,a|b|c|d      4+siz
  1238. subr.a           a|b|c|d   ,a|b|c|d      8
  1239.  
  1240. sub.a            #expr     ,d0|d1        8
  1241.  
  1242. inc.fs           a|b|c|d                 4+siz
  1243. inc.a            a|b|c|d                 8
  1244. dec.fs           a|b|c|d                 4+siz
  1245. dec.a            a|b|c|d                 8
  1246.  
  1247. inc.1            p                       4
  1248.  
  1249. neg.fs           a|b|c|d                 4+siz
  1250. neg.a            a|b|c|d                 8
  1251.  
  1252. not.fs           a|b|c|d                 4+siz
  1253. not.a            a|b|c|d                 8
  1254.  
  1255. or.fs            a|b|c|d   ,a|b|c|d      6+siz
  1256. or.a             a|b|c|d   ,a|b|c|d      11
  1257.  
  1258. and.fs           a|b|c|d   ,a|b|c|d      6+siz
  1259. and.a            a|b|c|d   ,a|b|c|d      11
  1260.  
  1261. lsl.fs           #4        ,a|b|c|d      5+siz
  1262. lsl.a            #4        ,a|b|c|d      9
  1263.  
  1264. lsr.fs           #4        ,a|b|c|d      5+siz
  1265. lsr.a            #4        ,a|b|c|d      9
  1266.  
  1267. lsr.w            #1        ,a|b|c|d      21
  1268.  
  1269. rol.w            #4        ,a|b|c|d      22
  1270. ror.w            #4        ,a|b|c|d      22
  1271.  
  1272. bset             #expr     ,a|c          8
  1273. bclr             #expr     ,a|c          8
  1274.  
  1275. bsr.3            rtn                     26   (the two's total)
  1276. bsr.4            rtn                     29
  1277.  
  1278. bra.3                                    14
  1279. bra.4                                    17
  1280.  
  1281.                            ;          taken/not taken
  1282. bcc.2                                    12/4
  1283.  
  1284. b??.fs           a|b|c|d   ,a|b|c|d|0    16+siz/8+siz
  1285. b??.a            a|b|c|d   ,a|b|c|d|0    21/13
  1286.  
  1287. beq.1            #expr     ,hst          16/8
  1288.  
  1289. beq.1            #expr     ,p            17/9
  1290.  
  1291. bbc|bbs          #expr     ,a|c          20/12
  1292.  
  1293. A.3.0 Overall Performance Comment
  1294. ---------------------------------
  1295.  
  1296. The processor's speed isn't very impressive. There's especially
  1297. one point of criticism to the developers I wish to say:
  1298. Everyone knows it's not possible to run handhelds processor clocks at
  1299. a high speed because of the temperature-problems that would cause
  1300. massive battery exhaust when semi-conductors get hot. But if so,
  1301. why the devil have you created such a cycle-eating micro-code?
  1302. There are so many nice processors around that do not need that much
  1303. cycles for each intruction (6800, 65xx, 8510 etc., even the Z80 needs
  1304. less cycles...), why does your's do???? 
  1305.  
  1306. The Clarke processor is able to move large amounts of data quicker
  1307. through memory than comparable processors because of it's 64-bit
  1308. registers. It is also fast on doing simple floating-point operations
  1309. (I'll explore the decimal-mode later...). But it is very slow
  1310. on more complex tasks as array-accessing, fixed-point operations
  1311. and parameter-passing to subroutines (the little stack...).
  1312.  
  1313.