Re: [Gm2] Compiling with pim-coroutine

[Gaius Mulley]

Gaius Mulley <address@hidden> writes:

> Johannes von Rotz <address@hidden> writes:
>
>> Hello Andreas,
>>
>> it seems I have misunderstood your post. I have now written a short
>> definition for MySystem as you suggested and the modules now compile
>> again. Thank you very much!
>>
>> What I don't understand is why the compilation works with INTEGER16 and
>> so on when using just the PIM library, but fails when using
>> pim-coroutine. Are they using a different revision of PIM?
>>
>> Also, when I try to import CARDINAL, INTEGER, SHORTINT and SHORTCARD
>> directly in ANSITYP.def and using them for the individual type
>> definitions, it doesn't work either. Why?
>>
>> Maybe I need to revisit the manual on the GM2 web site.
>>
>> Cheers,
>> Johannes
>
> Hi Johannes,
>
> I think there might be some missing data types in the pim coroutine
> SYSTEM.def.
>
> It might be worth turning on -fsources and compile your tiny test
> programs above.  You should see the SYSTEM.def parsed.  [In gm2
> SYSTEM.def and SYSTEM.mod are parsed].
>
> It is likely that in the pim-coroutine version of SYSTEM.def the sized
> data types do not appear, whereas in the pim libraries they are present.
> If you feel brave you can just cut and paste the sized data types from
> the pim SYSTEM.def into pim-coroutines SYSTEM.def.
>
> I believe this bug to be fixed in the 4.7.3 branch - I need to back port
> this fix into 4.1.2.
>
> Just checked this is the case so you could:
>
> paste these:
>
> INTEGER8, INTEGER16, INTEGER32, INTEGER64, CARDINAL8, CARDINAL16,
> CARDINAL32, CARDINAL64, WORD16, WORD32, WORD64,
> BITSET8, BITSET16, BITSET32, REAL32, REAL64, REAL96,
> REAL128, COMPLEX32, COMPLEX64, COMPLEX96, COMPLEX128,
>
> into:
>
> /opt/gm2/lib/gcc/x86_64-linux-gnu/4.1.2/gm2/pim-coroutine/SYSTEM.def
>
> and it should be fixed.
>
> regards,
> Gaius

Hi,

the paste should only be in the export qualified list as the compiler
declared all these types internally, and the SYSTEM.def exports those
types.  So it your SYSTEM.def should then look like this:

DEFINITION MODULE SYSTEM ;

FROM COROUTINES IMPORT PROTECTION ;

EXPORT QUALIFIED BITSPERBYTE, BYTESPERWORD,
                 LOC, WORD, BYTE, ADDRESS, INTEGER8,  
                 INTEGER16, INTEGER32, INTEGER64, CARDINAL8,  
                 CARDINAL16, CARDINAL32, CARDINAL64, WORD16,  
                 WORD32, WORD64, BITSET8, BITSET16,  
                 BITSET32, REAL32, REAL64, REAL96,  
                 REAL128, COMPLEX32, COMPLEX64, COMPLEX96,  
                 COMPLEX128,  
                 ADR, TSIZE, ROTATE, SHIFT, THROW, TBITSIZE,
                 (* SIZE is also exported if -fpim2 is used *)
                 PROCESS, TRANSFER, NEWPROCESS, IOTRANSFER,
                 LISTEN,
                 ListenLoop, TurnInterrupts ;


CONST
  BITSPERBYTE   = __ATTRIBUTE__ __BUILTIN__ ((BITS_PER_UNIT)) ;
  BYTESPERWORD  = __ATTRIBUTE__ __BUILTIN__ ((UNITS_PER_WORD)) ;


TYPE
   PROCESS  = RECORD
                 context: ADDRESS ;
                 ints   : PROTECTION ;
              END ;


(* all the following types are declared internally to gm2
TYPE
   LOC ; 
   WORD ; 
   BYTE ; 
   ADDRESS ; 
   INTEGER8 ; 
   INTEGER16 ; 
   INTEGER32 ; 
   INTEGER64 ; 
   CARDINAL8 ; 
   CARDINAL16 ; 
   CARDINAL32 ; 
   CARDINAL64 ; 
   WORD16 ; 
   WORD32 ; 
   WORD64 ; 
   BITSET8 ; 
   BITSET16 ; 
   BITSET32 ; 
   REAL32 ; 
   REAL64 ; 
   REAL96 ; 
   REAL128 ; 
   COMPLEX32 ; 
   COMPLEX64 ; 
   COMPLEX96 ; 
   COMPLEX128 ; 
*)


(*
   all the functions below are declared internally to gm2
   ====================================================

PROCEDURE ADR (VAR v: <anytype>): ADDRESS;
  (* Returns the address of variable v. *)

PROCEDURE SIZE (v: <type>) : ZType;
  (* Returns the number of BYTES used to store a v of
     any specified <type>.  Only available if -fpim2 is used.
  *)

PROCEDURE TSIZE (<type>) : CARDINAL;
  (* Returns the number of BYTES used to store a value of the
     specified <type>.
  *)

PROCEDURE ROTATE (val: <a set type>;
                  num: INTEGER): <type of first parameter>;
  (* Returns a bit sequence obtained from val by rotating up or down
     (left or right) by the absolute value of num.  The direction is
     down if the sign of num is negative, otherwise the direction is up.
  *)

PROCEDURE SHIFT (val: <a set type>;
                 num: INTEGER): <type of first parameter>;
  (* Returns a bit sequence obtained from val by shifting up or down
     (left or right) by the absolute value of num, introducing
     zeros as necessary.  The direction is down if the sign of
     num is negative, otherwise the direction is up.
  *)

PROCEDURE THROW (i: INTEGER) ;
  (*
     THROW is a GNU extension and was not part of the PIM or ISO
     standards.  It throws an exception which will be caught by the EXCEPT
     block (assuming it exists).  This is a compiler builtin function which
     interfaces to the GCC exception handling runtime system.
     GCC uses the term throw, hence the naming distinction between
     the GCC builtin and the Modula-2 runtime library procedure Raise.
     The later library procedure Raise will call SYSTEM.THROW after
     performing various housekeeping activities.
  *)

PROCEDURE TBITSIZE (<type>) : CARDINAL ;
  (* Returns the minimum number of bits necessary to represent
     <type>.  This procedure function is only useful for determining
     the number of bits used for any type field within a packed RECORD.
     It is not particularly useful elsewhere since <type> might be
     optimized for speed, for example a BOOLEAN could occupy a WORD.
  *)
*)

(* The following procedures are invoked by GNU Modula-2 to
   shift non word sized set types. They are not strictly part
   of the core PIM Modula-2, however they are used by
   GNU Modula-2 to implement the SHIFT procedure defined above,
   which are in turn used by the Logitech compatible libraries.

   Users will access these procedures by using the procedure
   SHIFT above and GNU Modula-2 will map SHIFT onto one of
   the following procedures.
*)

(*
   ShiftVal - is a runtime procedure whose job is to implement
              the SHIFT procedure of ISO SYSTEM. GNU Modula-2 will
              inline a SHIFT of a single WORD sized set and will only
              call this routine for larger sets.
*)

PROCEDURE ShiftVal (VAR s, d: ARRAY OF BITSET;
                    SetSizeInBits: CARDINAL;
                    ShiftCount: INTEGER) ;


(*
   ShiftLeft - performs the shift left for a multi word set.
               This procedure might be called by the back end of
               GNU Modula-2 depending whether amount is known at compile
               time.
*)

PROCEDURE ShiftLeft (VAR s, d: ARRAY OF BITSET;
                     SetSizeInBits: CARDINAL;
                     ShiftCount: CARDINAL) ;

(*
   ShiftRight - performs the shift left for a multi word set.
                This procedure might be called by the back end of
                GNU Modula-2 depending whether amount is known at compile
                time.
*)

PROCEDURE ShiftRight (VAR s, d: ARRAY OF BITSET;
                     SetSizeInBits: CARDINAL;
                     ShiftCount: CARDINAL) ;


(*
   RotateVal - is a runtime procedure whose job is to implement
               the ROTATE procedure of ISO SYSTEM. GNU Modula-2 will
               inline a ROTATE of a single WORD (or less)
               sized set and will only call this routine for larger sets.
*)

PROCEDURE RotateVal (VAR s, d: ARRAY OF BITSET;
                     SetSizeInBits: CARDINAL;
                     RotateCount: INTEGER) ;


(*
   RotateLeft - performs the rotate left for a multi word set.
                This procedure might be called by the back end of
                GNU Modula-2 depending whether amount is known at compile
                time.
*)

PROCEDURE RotateLeft (VAR s, d: ARRAY OF BITSET;
                      SetSizeInBits: CARDINAL;
                      RotateCount: CARDINAL) ;


(*
   RotateRight - performs the rotate right for a multi word set.
                 This procedure might be called by the back end of
                 GNU Modula-2 depending whether amount is known at compile
                 time.
*)

PROCEDURE RotateRight (VAR s, d: ARRAY OF BITSET;
                       SetSizeInBits: CARDINAL;
                       RotateCount: CARDINAL) ;



(*
   TRANSFER - save the current volatile environment into, p1.
              Restore the volatile environment from, p2.
*)

PROCEDURE TRANSFER (VAR p1: PROCESS; p2: PROCESS) ;


(*
   NEWPROCESS - p is a parameterless procedure, a, is the origin of
                the workspace used for the process stack and containing
                the volatile environment of the process. n, is the amount
                in bytes of this workspace. new, is the new process.
*)

PROCEDURE NEWPROCESS (p: PROC; a: ADDRESS; n: CARDINAL; VAR new: PROCESS) ;


(*
   IOTRANSFER - saves the current volatile environment into, First,
                and restores volatile environment, Second.
                When an interrupt, InterruptNo, is encountered then
                the reverse takes place. (The then current volatile
                environment is shelved onto Second and First is resumed).

                NOTE: that upon interrupt the Second might not be the
                      same process as that before the original call to
                      IOTRANSFER.
*)

PROCEDURE IOTRANSFER (VAR First, Second: PROCESS; InterruptNo: CARDINAL) ;


(*
   LISTEN - briefly listen for any interrupts.
*)

PROCEDURE LISTEN ;


(*
   ListenLoop - should be called instead of users writing:

                LOOP
                   LISTEN
                END

                It performs the same function but yields
                control back to the underlying operating system
                via a call to pth_select.
                It also checks for deadlock.
                This function returns when an interrupt occurs ie
                a file descriptor becomes ready or a time event expires.
                See the module RTint.
*)

PROCEDURE ListenLoop ;


(*
   TurnInterrupts - switches processor interrupts to the protection
                    level, to.  It returns the old value.
*)

PROCEDURE TurnInterrupts (to: PROTECTION) : PROTECTION ;



END SYSTEM.



hope this helps.

regards,
Gaius