home *** CD-ROM | disk | FTP | other *** search
/ ftp.ee.pdx.edu / 2014.02.ftp.ee.pdx.edu.tar / ftp.ee.pdx.edu / pub / users / Harry / compilers / p11 / tst / array1.out.bak < prev    next >
Text File  |  2006-03-05  |  7KB  |  364 lines
  1. !
  2. ! PCAT Compiler Version 1.0
  3. !
  4.              .global  .div
  5.              .global  .rem
  6. !
  7. ! Standard data fields
  8. !
  9.              .data
  10.              .align   8
  11. temp:        .double  0
  12.              .text
  13. strNL:       .asciz   "\n"
  14. strInt:      .asciz   "%d"
  15. strFlt:      .asciz   "%g"
  16. strTrue:     .asciz   "TRUE"
  17. strFalse:    .asciz   "FALSE"
  18. message1:    .asciz   "Execution Error: Allocation failed!\n"
  19. message2:    .asciz   "Execution Error: Pointer is NIL!\n"
  20. message3:    .asciz   "Execution Error: Read statement failed!\n"
  21. message4:    .asciz   "Execution Error: Array index is out of bounds!\n"
  22. message5:    .asciz   "Execution Error: Count is not positive in array constructor!\n"
  23.              .align   8
  24. !
  25. ! runtimeError1-5
  26. !
  27. ! Branch to one of these labels to print an error message and abort.
  28. !
  29. runtimeError1:
  30.              set      message1,%o0
  31.              call     printf
  32.              nop
  33.              call     exit
  34.              mov      1,%o0
  35. runtimeError2:
  36.              set      message2,%o0
  37.              call     printf
  38.              nop
  39.              call     exit
  40.              mov      1,%o0
  41. runtimeError3:
  42.              set      message3,%o0
  43.              call     printf
  44.              nop
  45.              call     exit
  46.              mov      1,%o0
  47. runtimeError4:
  48.              set      message4,%o0
  49.              call     printf
  50.              nop
  51.              call     exit
  52.              mov      1,%o0
  53. runtimeError5:
  54.              set      message5,%o0
  55.              call     printf
  56.              nop
  57.              call     exit
  58.              mov      1,%o0
  59. ! writeFlt
  60. !
  61. ! This routine is passed a single precision floating number in %f0.
  62. ! It prints it by calling printf.  It uses registers %f0, %f1.
  63. !
  64. writeFlt:
  65.         save    %sp,-128,%sp
  66.         fstod   %f0,%f0
  67.         set     temp,%l0
  68.         std     %f0,[%l0]
  69.         ldd     [%l0],%o0
  70.         mov     %o1,%o2
  71.         mov     %o0,%o1
  72.         set     strFlt,%o0
  73.         call    printf
  74.         nop
  75.         ret
  76.         restore
  77. ! writeBool
  78. !
  79. ! This routine is passed an integer in %i0/o0.  It prints "FALSE" if this
  80. ! integer is 0 and "TRUE" otherwise.
  81. !
  82. writeBool:
  83.         save    %sp,-128,%sp
  84.         cmp     %i0,%g0
  85.         be      printFalse
  86.         nop
  87.         set     strTrue,%o0
  88.         ba      printEnd
  89.         nop
  90. printFalse:
  91.         set     strFalse,%o0
  92. printEnd:
  93.         call    printf
  94.         nop
  95.         ret
  96.         restore
  97. !
  98. ! Additional Fields
  99. !
  100.     .data
  101. display0:    .word    0
  102.     .text
  103. str3:    .asciz    "Should print 333..."
  104. str2:    .asciz    "Should print 222..."
  105. str1:    .asciz    "Should print 111..."
  106.     .align    8
  107. ! MAIN...
  108. !   mainEntry
  109.     .global    main
  110. main:    save    %sp,-136,%sp
  111.     set    display0,%o0
  112.     st    %fp,[%o0]
  113. ! VAR INITIALIZATION...
  114. !   a := 0
  115.     set    0,%o0
  116.     st    %o0,[%fp+-4]
  117. ! ASSIGNMENT STMT...
  118. !   t1 := 0
  119.     set    0,%o0
  120.     st    %o0,[%fp+-8]
  121. !   t1 := t1 + 1        (integer)
  122.     ld    [%fp+-8],%o0
  123.     set    1,%o1
  124.     add    %o0,%o1,%o1
  125.     st    %o1,[%fp+-8]
  126. !   t1 := t1 + 1        (integer)
  127.     ld    [%fp+-8],%o0
  128.     set    1,%o1
  129.     add    %o0,%o1,%o1
  130.     st    %o1,[%fp+-8]
  131. !   t1 := t1 + 1        (integer)
  132.     ld    [%fp+-8],%o0
  133.     set    1,%o1
  134.     add    %o0,%o1,%o1
  135.     st    %o1,[%fp+-8]
  136. !   t2 := t1 * 4        (integer)
  137.     ld    [%fp+-8],%o0
  138.     set    4,%o1
  139.     smul    %o0,%o1,%o1
  140.     st    %o1,[%fp+-12]
  141. !   t2 := t2 + 4        (integer)
  142.     ld    [%fp+-12],%o0
  143.     set    4,%o1
  144.     add    %o0,%o1,%o1
  145.     st    %o1,[%fp+-12]
  146. !   t2 := alloc (t2)
  147.     set    1,%o0
  148.     ld    [%fp+-12],%o1
  149.     call    calloc
  150.     nop
  151.     st    %o0,[%fp+-12]
  152. !   if t2 = 0 goto runtimeError1        (integer)
  153.     ld    [%fp+-12],%o0
  154.     set    0,%o1
  155.     cmp    %o0,%o1
  156.     be    runtimeError1
  157.     nop
  158. !   t3 := t2
  159.     ld    [%fp+-12],%o0
  160.     st    %o0,[%fp+-16]
  161. !   *t2 := t1
  162.     ld    [%fp+-8],%o0
  163.     ld    [%fp+-12],%o1
  164.     st    %o0,[%o1]
  165. !   t2 := t2 + 4        (integer)
  166.     ld    [%fp+-12],%o0
  167.     set    4,%o1
  168.     add    %o0,%o1,%o1
  169.     st    %o1,[%fp+-12]
  170. !   *t2 := 111
  171.     set    111,%o0
  172.     ld    [%fp+-12],%o1
  173.     st    %o0,[%o1]
  174. !   t2 := t2 + 4        (integer)
  175.     ld    [%fp+-12],%o0
  176.     set    4,%o1
  177.     add    %o0,%o1,%o1
  178.     st    %o1,[%fp+-12]
  179. !   *t2 := 222
  180.     set    222,%o0
  181.     ld    [%fp+-12],%o1
  182.     st    %o0,[%o1]
  183. !   t2 := t2 + 4        (integer)
  184.     ld    [%fp+-12],%o0
  185.     set    4,%o1
  186.     add    %o0,%o1,%o1
  187.     st    %o1,[%fp+-12]
  188. !   *t2 := 333
  189.     set    333,%o0
  190.     ld    [%fp+-12],%o1
  191.     st    %o0,[%o1]
  192. !   a := t3
  193.     ld    [%fp+-16],%o0
  194.     st    %o0,[%fp+-4]
  195. ! WRITE STMT...
  196. !   writeString str1
  197.     sethi    %hi(str1),%o0
  198.     call    printf
  199.     or    %o0,%lo(str1),%o0
  200. !   if a = 0 goto runtimeError2        (integer)
  201.     ld    [%fp+-4],%o0
  202.     set    0,%o1
  203.     cmp    %o0,%o1
  204.     be    runtimeError2
  205.     nop
  206. !   if 0 < 0 goto runtimeError4        (integer)
  207.     set    0,%o0
  208.     set    0,%o1
  209.     cmp    %o0,%o1
  210.     bl    runtimeError4
  211.     nop
  212. !   t5 := *a
  213.     ld    [%fp+-4],%o0
  214.     ld    [%o0],%o0
  215.     st    %o0,[%fp+-24]
  216. !   if 0 >= t5 goto runtimeError4        (integer)
  217.     set    0,%o0
  218.     ld    [%fp+-24],%o1
  219.     cmp    %o0,%o1
  220.     bge    runtimeError4
  221.     nop
  222. !   t5 := 0 * 4        (integer)
  223.     set    0,%o0
  224.     set    4,%o1
  225.     smul    %o0,%o1,%o1
  226.     st    %o1,[%fp+-24]
  227. !   t5 := t5 + 4        (integer)
  228.     ld    [%fp+-24],%o0
  229.     set    4,%o1
  230.     add    %o0,%o1,%o1
  231.     st    %o1,[%fp+-24]
  232. !   t5 := a + t5        (integer)
  233.     ld    [%fp+-4],%o0
  234.     ld    [%fp+-24],%o1
  235.     add    %o0,%o1,%o1
  236.     st    %o1,[%fp+-24]
  237. !   t6 := *t5
  238.     ld    [%fp+-24],%o0
  239.     ld    [%o0],%o0
  240.     st    %o0,[%fp+-28]
  241. !   writeInt t6
  242.     ld    [%fp+-28],%o1
  243.     sethi    %hi(strInt),%o0
  244.     call    printf
  245.     or    %o0,%lo(strInt),%o0
  246. !   writeNewline
  247.     sethi    %hi(strNL),%o0
  248.     call    printf
  249.     or    %o0,%lo(strNL),%o0
  250. ! WRITE STMT...
  251. !   writeString str2
  252.     sethi    %hi(str2),%o0
  253.     call    printf
  254.     or    %o0,%lo(str2),%o0
  255. !   if a = 0 goto runtimeError2        (integer)
  256.     ld    [%fp+-4],%o0
  257.     set    0,%o1
  258.     cmp    %o0,%o1
  259.     be    runtimeError2
  260.     nop
  261. !   if 1 < 0 goto runtimeError4        (integer)
  262.     set    1,%o0
  263.     set    0,%o1
  264.     cmp    %o0,%o1
  265.     bl    runtimeError4
  266.     nop
  267. !   t7 := *a
  268.     ld    [%fp+-4],%o0
  269.     ld    [%o0],%o0
  270.     st    %o0,[%fp+-32]
  271. !   if 1 >= t7 goto runtimeError4        (integer)
  272.     set    1,%o0
  273.     ld    [%fp+-32],%o1
  274.     cmp    %o0,%o1
  275.     bge    runtimeError4
  276.     nop
  277. !   t7 := 1 * 4        (integer)
  278.     set    1,%o0
  279.     set    4,%o1
  280.     smul    %o0,%o1,%o1
  281.     st    %o1,[%fp+-32]
  282. !   t7 := t7 + 4        (integer)
  283.     ld    [%fp+-32],%o0
  284.     set    4,%o1
  285.     add    %o0,%o1,%o1
  286.     st    %o1,[%fp+-32]
  287. !   t7 := a + t7        (integer)
  288.     ld    [%fp+-4],%o0
  289.     ld    [%fp+-32],%o1
  290.     add    %o0,%o1,%o1
  291.     st    %o1,[%fp+-32]
  292. !   t8 := *t7
  293.     ld    [%fp+-32],%o0
  294.     ld    [%o0],%o0
  295.     st    %o0,[%fp+-36]
  296. !   writeInt t8
  297.     ld    [%fp+-36],%o1
  298.     sethi    %hi(strInt),%o0
  299.     call    printf
  300.     or    %o0,%lo(strInt),%o0
  301. !   writeNewline
  302.     sethi    %hi(strNL),%o0
  303.     call    printf
  304.     or    %o0,%lo(strNL),%o0
  305. ! WRITE STMT...
  306. !   writeString str3
  307.     sethi    %hi(str3),%o0
  308.     call    printf
  309.     or    %o0,%lo(str3),%o0
  310. !   if a = 0 goto runtimeError2        (integer)
  311.     ld    [%fp+-4],%o0
  312.     set    0,%o1
  313.     cmp    %o0,%o1
  314.     be    runtimeError2
  315.     nop
  316. !   if 2 < 0 goto runtimeError4        (integer)
  317.     set    2,%o0
  318.     set    0,%o1
  319.     cmp    %o0,%o1
  320.     bl    runtimeError4
  321.     nop
  322. !   t9 := *a
  323.     ld    [%fp+-4],%o0
  324.     ld    [%o0],%o0
  325.     st    %o0,[%fp+-40]
  326. !   if 2 >= t9 goto runtimeError4        (integer)
  327.     set    2,%o0
  328.     ld    [%fp+-40],%o1
  329.     cmp    %o0,%o1
  330.     bge    runtimeError4
  331.     nop
  332. !   t9 := 2 * 4        (integer)
  333.     set    2,%o0
  334.     set    4,%o1
  335.     smul    %o0,%o1,%o1
  336.     st    %o1,[%fp+-40]
  337. !   t9 := t9 + 4        (integer)
  338.     ld    [%fp+-40],%o0
  339.     set    4,%o1
  340.     add    %o0,%o1,%o1
  341.     st    %o1,[%fp+-40]
  342. !   t9 := a + t9        (integer)
  343.     ld    [%fp+-4],%o0
  344.     ld    [%fp+-40],%o1
  345.     add    %o0,%o1,%o1
  346.     st    %o1,[%fp+-40]
  347. !   t10 := *t9
  348.     ld    [%fp+-40],%o0
  349.     ld    [%o0],%o0
  350.     st    %o0,[%fp+-44]
  351. !   writeInt t10
  352.     ld    [%fp+-44],%o1
  353.     sethi    %hi(strInt),%o0
  354.     call    printf
  355.     or    %o0,%lo(strInt),%o0
  356. !   writeNewline
  357.     sethi    %hi(strNL),%o0
  358.     call    printf
  359.     or    %o0,%lo(strNL),%o0
  360. ! MAIN EXIT...
  361. !   mainExit
  362.     ret
  363.     restore
  364.