gcc/testsuite/g++.old-deja/g++.eh/badalloc1.C

   1 // { dg-do run { xfail xstormy16-*-* *-*-darwin* } }
   2 // Copyright (C) 2000, 2002, 2003 Free Software Foundation, Inc.
   3 // Contributed by Nathan Sidwell 6 June 2000 <nathan@codesourcery.com>
   4
   5 // Check we can throw a bad_alloc exception when malloc dies.
   6
   7 typedef __SIZE_TYPE__ size_t;
   8 extern "C" void abort();
   9 extern "C" void *memcpy(void *, const void *, size_t);
  10
  11 // Assume that STACK_SIZE defined implies a system that does not have a
  12 // large data space either, and additionally that we're not linking against
  13 // a shared libstdc++ (which requires quite a bit more initialization space).
  14 #ifdef STACK_SIZE
  15 const int arena_size = 256;
  16 #else
  17 #ifdef __FreeBSD__
  18 // FreeBSD with threads requires even more space at initialization time.
  19 #include "bits/c++config.h"
  20 #include "bits/gthr.h"
  21 const int arena_size = 131072;
  22 #else
  23 const int arena_size = 32768;
  24 #endif
  25 #endif
  26
  27 struct object
  28 {
  29   size_t size __attribute__((aligned));
  30 };
  31
  32 static char arena[arena_size] __attribute__((aligned));
  33 static size_t pos;
  34
  35 // So we can force a failure when needed.
  36 static int fail;
  37
  38 extern "C" void *malloc (size_t size)
  39 {
  40   object *p = reinterpret_cast<object *>(&arena[pos]);
  41
  42   if (fail)
  43     return 0;
  44
  45   p->size = size;
  46   size = (size + __alignof__(object) - 1) & - __alignof__(object);
  47   pos += size + sizeof(object);
  48
  49   // Verify that we didn't run out of memory before getting initialized.
  50   if (pos > arena_size)
  51     abort ();
  52
  53   return p + 1;
  54 }
  55
  56 extern "C" void free (void *)
  57 {
  58 }
  59
  60 extern "C" void *realloc (void *p, size_t size)
  61 {
  62   void *r;
  63
  64   if (p)
  65     {
  66       object *o = reinterpret_cast<object *>(p) - 1;
  67       size_t old_size = o->size;
  68
  69       if (old_size >= size)
  70         {
  71           r = p;
  72           o->size = size;
  73         }
  74       else
  75         {
  76           r = malloc (size);
  77           memcpy (r, p, old_size);
  78           free (p);
  79         }
  80     }
  81   else
  82     r = malloc (size);
  83
  84   return r;
  85 }
  86
  87 void fn_throw() throw(int)
  88 {
  89   throw 1;
  90 }
  91
  92 void fn_rethrow() throw(int)
  93 {
  94   try{fn_throw();}
  95   catch(int a){
  96     throw;}
  97 }
  98
  99 void fn_catchthrow() throw(int)
 100 {
 101   try{fn_throw();}
 102   catch(int a){
 103     throw a + 1;}
 104 }
 105
 106 int main()
 107 {
 108 #ifdef __FreeBSD__
 109 // FreeBSD with threads fails the test unless each thread primes itself.
 110   if (__gthread_active_p())
 111     {
 112       try{fn_throw();}
 113       catch(int a){}
 114     }
 115 // This was added to test with well-known idiom to detect regressions here
 116 // rather than always failing with -pthread.
 117 #endif
 118
 119   fail = 1;
 120
 121   try{fn_throw();}
 122   catch(int a){}
 123
 124   try{fn_rethrow();}
 125   catch(int a){}
 126
 127   try{fn_catchthrow();}
 128   catch(int a){}
 129
 130   return 0;
 131 }