[Oberon] FPGA Oberon Article in Xilinx Xcell Journal

David Hunter drhunter at frontiernet.net
Fri May 15 01:06:37 CEST 2015


It was a good article.

I concur that system integrity can definitely be violated.   I did a 
quick example of an array overflow.   (see the code at the end of this 
post)    I ran it on a Spartan FPGA and it printed all 12 characters 
without a problem.   From what I can tell looking at the disassembled 
code, the RISC5 compiler does not add "run time checking."

Dave

On 5/14/2015 6:00 AM, oberon-request at lists.inf.ethz.ch wrote:
> ------------------------------
>
> Message: 4
> Date: Wed, 13 May 2015 19:47:49 +0200
> From: Michael Schierl<schierlm at gmx.de>
> Subject: Re: [Oberon] FPGA Oberon Article in Xilinx Xcell Journal
> 	(Issue 91)
> To:oberon at lists.inf.ethz.ch
> Message-ID:<55538E45.5020303 at gmx.de>
> Content-Type: text/plain; charset=windows-1252
>
> Am 13.05.2015 um 15:15 schrieb Srinivas Nayak:
>
>> >Good to see the article.
>> >Here is the pdf.
>> >www.xilinx.com/publications/archives/xcell/Xcell91.pdf
> Quoted from the article:
>
> "In fact, system integrity can be violated only by the use of operations
> in the pseudo-module SYSTEM, namely PUT and COPY"
>
>
> That's wishful thinking... System integrity can easily be violated by
> accessing uninitialized variables on the stack (it is left as an
> exercise to the reader to abuse this for implementing SYSTEM.PUT for the
> RISC processor in pure Oberon without importing the SYSTEM module). And
> there is no easy way of fixing this that does not impact performance
> (like initializing all variables on the stack), as the Oberon language
> neither has a notion of uninitialized variables, nor of "out" parameters.
>
> I think the bug in System.Clear that sometimes overwrites some random
> piece of memory due to accessing an uninitialized pointer has not been
> fixed yet in the source published on Project Oberon, either.
>
>
> But apart from that, I like the article, too:)
>
>
> Regards,
>
>
> Michael
>


=================================================================================================
Source:

(* Overflow.Mod
*
*    (c) SkuTek Instrumentation
*    D. Hunter
*    This program tests if array bounds checking is done
*    Versions:
*        0.1    05/14/15    DH    - initial version
*)

MODULE* Overflow;    (* embedded module *)
     IMPORT SYSTEM;

     CONST
         (* ASCII characters *)
         LF = 0AX;
         CR = 0DX;                    (* CR / LF characters *)
         SPC = 20X;                (* space character *)
         PRMPT = 23X;            (* prompt character = # *)
         DOT = 2EX;                (* period or decimal point *)

          (* I/O addresses at top of memory map,
             NOTE: the values need to be negative to generate the 
correct instructions *)
         UDATA = -56;        (* UART data *)
         USTAT = -52;        (* UART status *)

         (* UART status flags *)
         RXF = 0;                (* receive ready flag is in bit 0 *)
         TXF = 1;                (* transmit ready flag is in bit 1 *)

         (* test parameters *)
         SIZE = 10;            (* array size *)
         STOP = 12;            (* stop index *)


     VAR
         i : INTEGER;
         test: ARRAY SIZE OF CHAR;
     (* ========================================= *)
     (* UART transmit procedures *)

     (* send a character to the UART
         NOTE: the extra time converting to a set helps slow down
         the polling, which is desired with such a fast processor *)
     PROCEDURE PutChar(c: CHAR);
     VAR
         s: SET;            (* status bit field *)
         stat: INTEGER;    (* integer status *)
     BEGIN
         REPEAT                    (* wait for a transmitter ready *)
             SYSTEM.GET(USTAT,stat);    (* get UART status *)
             s := SYSTEM.VAL(SET,stat)    (* convert to set *)
         UNTIL (TXF IN s);        (* loop until transmit ready is set *)

         SYSTEM.PUT(UDATA,ORD(c))        (* send character *)
     END PutChar;

     (* ========================================= *)
     (* send a CR/LF to the UART *)
     PROCEDURE WriteLn;
     BEGIN
         PutChar(CR);
         PutChar(LF)
     END WriteLn;

     (* main program *)

     BEGIN
         REPEAT
             LED(0);
             PutChar(PRMPT); PutChar(SPC);
             FOR i := 0 TO STOP DO;
                 test[i] := CHR(41H + i);        (* store character into 
the array *)
                 PutChar(test[i])
             END;
             PutChar(DOT); WriteLn;
             LED(2);
             FOR i := 0 TO 100000 DO;    (* pause *)
             END;
         UNTIL FALSE;

END Overflow.

=================================================================================================
Compiled code with Oberon module added:

ORTool 29.10.2014
decode Overflow.rsc
Overflow E9D4E4B5   0   340
imports:
type descriptors

data    16
strings

code
    0     E7000021    B      33                ; branch start
    1     00000000    MOV  R0  R0  R0
    2     00000000    MOV  R0  R0  R0
    3     00000000    MOV  R0  R0  R0
    4     00000000    MOV  R0  R0  R0
    5     00000000    MOV  R0  R0  R0
    6     00000000    MOV  R0  R0  R0
    7     00000000    MOV  R0  R0  R0
    8     4EE90010    SUB SP SP     16        PROCEDURE PutChar(c);
    9     AFE00000    STR  LNK SP       0        BEGIN
   10     A0E00004    STR   R0 SP       4                [ save c on stack ]
   11     5000FFCC    MOV  R0  R0    -52                REPEAT
   12     80000000    LDR  R0  R0       0 SYSTEM.GET(USTAT,stat);
   13     A0E0000C    STR   R0 SP      12
   14     80E0000C    LDR  R0 SP      12
   15     A0E00008    STR   R0 SP       8                    s := 
SYSTEM.VAL(SET, stat)
   16     80E00008    LDR  R0 SP       8
   17     40030002    ROR  R0  R0      2
   18     E8FFFFF8    BPL      -8                        UNTIL (TXF in s);
   19     90E00004    LDR  R0 SP       4
   20     5100FFC8    MOV  R1  R0    -56
   21     A0100000    STR   R0  R1       0 SYSTEM.PUT(UDATA,ORD(c))
   22     8FE00000    LDR LNK SP       0
   23     4EE80010    ADD SP SP     16
   24     C700000F    B LNK                    END PutChar;
   25     4EE90004    SUB SP SP      4        PROCEDURE WriteLn;
   26     AFE00000    STR  LNK SP       0        BEGIN
   27     4000000D    MOV  R0  R0     13
   28     F7FFFFEB    BL     -21                    PutChar(CR);
   29     4000000A    MOV  R0  R0     10
   30     F7FFFFE9    BL     -23                    PutChar(LF);
   31     8FE00000    LDR LNK SP       0
   32     4EE80004    ADD SP SP      4
   33     C700000F    B LNK                    END WriteLn;
   34     4D000010    MOV SB  R0     16        Entry:    set SB = 16
   35     4E008000    MOV SP  R0 -32768                set SP = 8000H
   36     40000000    MOV  R0  R0      0        BEGIN REPEAT
   37     5100FFC4    MOV  R1  R0    -60
   38     A0100000    STR   R0  R1       0            LED(0);
   39     40000023    MOV  R0  R0     35
   40     F7FFFFDF    BL     -33 PutChar(PRMPT);
   41     40000020    MOV  R0  R0     32
   42     F7FFFFDD    BL     -35 PutChar(SPC);
   43     40000000    MOV  R0  R0      0                FOR i := 0 TO 
STOP DO;
   44     4109000C    SUB  R1  R0     12
   45     EE00000E    BGT       14
   46     A0D00000    STR   R0 SB       0
   47     80D00000    LDR  R0 SB       0
   48     00D80000    ADD  R0 SB  R0
   49     41000041    MOV  R1  R0     65
   50     82D00000    LDR  R2 SB       0
   51     01180002    ADD  R1  R1  R2
   52     B1000004    STR   R1  R0       4                test[i] := 
CHR(41H + 1);
   53     80D00000    LDR  R0 SB       0
   54     00D80000    ADD  R0 SB  R0
   55     90000004    LDR  R0  R0       4
   56     F7FFFFCF    BL     -49 PutChar(test[i]);
   57     80D00000    LDR  R0 SB       0
   58     40080001    ADD  R0  R0      1
   59     E7FFFFF0    B     -16                        END;
   60     4000002E    MOV  R0  R0     46
   61     F7FFFFCA    BL     -54 PutChar(DOT);
   62     F7FFFFDA    BL     -38                        WriteLn;
   63     40000002    MOV  R0  R0      2
   64     5100FFC4    MOV  R1  R0    -60
   65     A0100000    STR   R0  R1       0            LED(2);
   66     40000000    MOV  R0  R0      0                FOR i := 0 TO 
100000 DO;
   67     61000001    MOV'  R1  R0      1
   68     411686A0    IOR  R1  R1 -31072
   69     01090001    SUB  R1  R0  R1
   70     EE000004    BGT        4
   71     A0D00000    STR   R0 SB       0
   72     80D00000    LDR  R0 SB       0
   73     40080001    ADD  R0  R0      1
   74     E7FFFFF8    B      -8                        END;
   75     E7FFFFD8    B     -40                    UNTIL FALSE;
   76     40000000    MOV  R0  R0      0
   77     C7000000    B  R0                        Branch to 00000H 
[never executed]


---
This email has been checked for viruses by Avast antivirus software.
http://www.avast.com
-------------- next part --------------
An HTML attachment was scrubbed...
URL: https://lists.inf.ethz.ch/pipermail/oberon/attachments/20150514/f69980a9/attachment.html 


More information about the Oberon mailing list