Esempio n. 1
0
int main ()
{
  callee1 (2, "A string argument.", 3.5);
  callee1 (2, "A string argument.", 3.5);

  do_nothing (); /* Hello, World! */

  callme (1);
  callme (2);

  return 0;
}
main ()
{
  callee1 (2, "A string argument.", 3.5);
  callee1 (2, "A string argument.", 3.5);

  printf ("Hello, World!");

  callme (1);
  callme (2);

  return 0;
}
Esempio n. 3
0
main ()
{
    func callme = get_callback ();
    if (callme (0, 0, 0, 0x1234, 0x1234567890abcdefLL))
        abort ();
    return 0;
}
Esempio n. 4
0
int
bar (int i)
{
  try {
    __builtin_printf ("foo %d\n", i);
  } catch (...) {
    callme();
  }
}
Esempio n. 5
0
int
foo (int i)
{
  try {
    printf ("foo %d\n", i);
  } catch (...) {
    callme();
  }
}
Esempio n. 6
0
void callme(struct big_struct bs)
{
	volatile int minfree = StackHeapMinFree();
	debug_printf("\t Call(%d) MinRemainingStack: %d; Stack Free: %d\n",
										callcount++,
										minfree,
										(int)StackHeapFree());
    if((bs.i) && (minfree > sizeof(g_bs)))
    {
        bs.i--;
        callme(bs);
    }
}
void *
child_function_2 (void *arg)
{
  int my_number =  (long) arg;
  volatile int *myp = (int *) &args[my_number];

  pthread_barrier_wait (&barrier);

  while (*myp > 0)
    {
      (*myp) ++;
      callme (); /* set breakpoint child_one here */
    }

  *myp = 1;
  while (*myp > 0)
    {
      (*myp) ++;
      callme ();
    }

  pthread_exit (NULL);
}
int
main ()
{
  int res;
  long i;

  signal (SIGUSR1, handler);

  /* Call these early so that PLTs for these are resolved soon,
     instead of in the threads.  RTLD_NOW should work as well.  */
  usleep (0);
  pthread_barrier_init (&barrier, NULL, 1);
  pthread_barrier_wait (&barrier);

  pthread_barrier_init (&barrier, NULL, 2);

  i = 0;
  args[i] = 1;
  res = pthread_create (&child_thread_2,
			NULL, child_function_2, (void *) i);
  pthread_barrier_wait (&barrier);
  callme (); /* set wait-thread-2 breakpoint here */

  i = 1;
  args[i] = 1;
  res = pthread_create (&child_thread_3,
			NULL, child_function_3, (void *) i);
  pthread_barrier_wait (&barrier);
  callme (); /* set wait-thread-3 breakpoint here */

  pthread_kill (child_thread_2, SIGUSR1);

  pthread_join (child_thread_2, NULL);
  pthread_join (child_thread_3, NULL);

  exit(EXIT_SUCCESS);
}
Esempio n. 9
0
// load a valid module, export a symbol, call it, and unload module
void Test1()
{
    DynamicLibrary library(getLibraryFileName(VALID_LIBRARY_NAME));
    PEGASUS_TEST_ASSERT(library.getFileName() ==
        getLibraryFileName(VALID_LIBRARY_NAME));

    library.load();
    PEGASUS_TEST_ASSERT(library.isLoaded());

    Uint32 (* callme)(void) = (Uint32 (*)(void))library.getSymbol("callme");
    PEGASUS_TEST_ASSERT(callme);
    PEGASUS_TEST_ASSERT(callme() == 0xdeadbeef);

    Uint32 (* badfunc)(void) = (Uint32 (*)(void))library.getSymbol("badfunc");
    PEGASUS_TEST_ASSERT(badfunc == 0);

    library.unload();
    PEGASUS_TEST_ASSERT(!library.isLoaded());
}
Esempio n. 10
0
int main(void)
{
	debug_printf("Starting with %d bytes of stack/heap. max/current usage: %d/%d. Size of one struct: %d\n",
	        (int)StackHeapSize(), (int)StackHeapMinFree(), (int)StackHeapFree(), sizeof(g_bs));

	while(1)
	{
		callcount = 0;
	    callme(g_bs);
	    debug_printf("callme(%d): %d/%d\n", g_bs.i, (int)StackHeapMinFree(), (int)StackHeapFree());
            g_bs.i++;
    }


	// Enter an infinite loop, just incrementing a counter
	volatile static int i = 0 ;
	while(1) {
		i++ ;
	}
	return 0 ;
}
Esempio n. 11
0
int
main (void)
{
  struct sigaction sa;
  int i;

  callme ();

  memset (&sa, 0, sizeof (sa));
  sa.sa_sigaction = handler;
  sa.sa_flags = SA_SIGINFO;

  i = sigemptyset (&sa.sa_mask);
  assert (i == 0);

  i = sigaction (SIGUSR1, &sa, NULL);
  assert (i == 0);

  i = raise (SIGUSR1);
  assert (i == 0);

  sleep (600);
  return 0;
}