OberonCore

MODULE VeryBad;

   IMPORT S := SYSTEM, Log, M := Services;

   CONST size = 10000000;
   TYPE
      Ptr = POINTER TO Rec;
      Rec = RECORD
         prefix: RECORD x, y, z: REAL END;
         v: ARRAY size OF INTEGER
      END;
   VAR p, q: Ptr;
      nfins: INTEGER;
   
   PROCEDURE (p: Ptr) FINALIZE-;
   BEGIN
      INC(nfins);
      Log.String("Finalize! "); Log.IntForm(S.VAL(INTEGER, p), 16, 8, '0', FALSE);
      Log.Int(p.v[0]); Log.Ln
   END FINALIZE;

   PROCEDURE Test* ;
      VAR p: Ptr;
      
      PROCEDURE PrintPtr(p: Ptr);
      BEGIN
         Log.String("p = ");
         Log.IntForm(S.VAL(INTEGER, p), 16, 8, '0', FALSE); Log.Ln;
      END PrintPtr;
      
      PROCEDURE Bad(VAR a: INTEGER);
         VAR i: INTEGER;
      BEGIN
         nfins := 0;
         REPEAT
            NEW(p); (* GC will be called here *)
            PrintPtr(p);
            IF (S.VAL(INTEGER, p) <= S.ADR(a)) & (S.ADR(a) < S.VAL(INTEGER, p) + SIZE(Rec)) THEN
               Log.String("Попался!!!"); Log.Ln;
               a := 10;
               FOR i := 0 TO LEN(p.v)-1 DO
                  IF p.v[i] = 10 THEN
                     Log.String("p[");
                     Log.Int(i);
                     Log.String("] =");
                     Log.Int(p.v[i]); Log.Ln
                  END;
                  RETURN;
               END;
               RETURN;
            END;
            a := 10;
         UNTIL (p.v[10] = 10) OR (nfins >= 200);
      END Bad;
   BEGIN
      NEW(p);
      PrintPtr(p);
      Bad(p.v[0]);
   END Test;

END VeryBad.

(!) VeryBad.Test

MODULE TestCrash;

   IMPORT Log;

   PROCEDURE Do*; (* (!)TestCrash.Do *)
      VAR
         p: POINTER TO RECORD
            prefix: ARRAY 1000000 OF BYTE;
            v: ARRAY 1 OF BOOLEAN;
         END;

      PROCEDURE Crash (VAR x: BOOLEAN);
      BEGIN
         REPEAT
            NEW(p);
            x := TRUE
         UNTIL p.v[0];
         Log.String("Crashed!!!"); Log.Ln
      END Crash;
   
   BEGIN
      NEW(p);
      Crash(p.v[0])
   END Do;

END TestCrash.

MODULE TestCrash;

   IMPORT Log;

   PROCEDURE Do*; (* TestCrash.Do *)
      VAR a: POINTER TO ARRAY 100000 OF BOOLEAN;

      PROCEDURE Crash (VAR b: BOOLEAN);
      BEGIN
         REPEAT
            NEW(a);
            b := TRUE
         UNTIL a[0]
      END Crash;
   
   BEGIN
      NEW(a);
      Crash(a[0]);
      Log.String("Crashed!!!"); Log.Ln
   END Do;

END TestCrash.

PROCEDURE Do*;
VAR p,q : POINTER TO ARRAY 10 OF CHAR;
   PROCEDURE Foo(VAR x: CHAR);
   BEGIN
     p := NIL;
     Kernel.Collect;
     NEW(q);  q^:='abcdefgh';
     x:='!';
   END Foo;
BEGIN
   Kernel.Collect;
   NEW(p);
   Foo(p[2]);
   Log.String(q); Log.Ln
END Do;

push ebp
mov esp,ebp

xor eax,eax
mov d,[eax],1

VAR p: POINTER TO RECORD ... v: INTEGER; ... END;
...
PROCEDURE foo(VAR a: INTEGER);
BEGIN ... END foo;
...
(* здесь что-то вроде push p *)
foo(p.v);
(* здесь, например, add %sp,4,%sp *)
...