From f8e87ab13d54060a94f01e4e12bb9f97d7be512c Mon Sep 17 00:00:00 2001 From: akr Date: Fri, 1 Sep 2006 18:47:11 +0000 Subject: [PATCH] * common.mk, configure.in, defines.h, eval.c, gc.c, main.c, numeric.c, ruby.h, ia64.s: backport IA64 HP-UX support. git-svn-id: http://svn.ruby-lang.org/repos/ruby/branches/ruby_1_8@10827 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ChangeLog | 5 ++ common.mk | 1 + configure.in | 61 +++++++++++++--- defines.h | 11 ++- eval.c | 198 ++++++++++++++++++++++++++++----------------------- gc.c | 95 +++++++++++++++--------- main.c | 9 ++- numeric.c | 4 ++ ruby.h | 25 +++++-- 9 files changed, 264 insertions(+), 145 deletions(-) diff --git a/ChangeLog b/ChangeLog index e684030f19..5fc5b0ee99 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +Sat Sep 2 03:36:22 2006 Tanaka Akira + + * common.mk, configure.in, defines.h, eval.c, gc.c, main.c, + numeric.c, ruby.h, ia64.s: backport IA64 HP-UX support. + Fri Sep 1 13:52:57 2006 Hidetoshi NAGAI * ext/tk/lib/tk/font.rb: TkFont#current_configinfo() doesn't work diff --git a/common.mk b/common.mk index cf3e959566..ed46536684 100644 --- a/common.mk +++ b/common.mk @@ -189,6 +189,7 @@ nt.$(OBJEXT): {$(VPATH)}nt.c x68.$(OBJEXT): {$(VPATH)}x68.c os2.$(OBJEXT): {$(VPATH)}os2.c dl_os2.$(OBJEXT): {$(VPATH)}dl_os2.c +ia64.$(OBJEXT): ia64.s # when I use -I., there is confliction at "OpenFile" # so, set . into environment varible "include" diff --git a/configure.in b/configure.in index 8ee5e6d871..ddfa4b28b3 100644 --- a/configure.in +++ b/configure.in @@ -286,16 +286,42 @@ if test "$rb_cv_stdarg" = yes; then AC_DEFINE(HAVE_STDARG_PROTOTYPES) fi -AC_CACHE_CHECK([for noreturn], rb_cv_noreturn, -[rb_cv_noreturn=x -for mac in "x __attribute__ ((noreturn))" "__declspec(noreturn) x" x; do +AC_DEFUN([RUBY_FUNC_ATTRIBUTE], [dnl +m4_ifval([$2], dnl + [AS_VAR_PUSHDEF([attrib],[$2])], dnl + [AS_VAR_PUSHDEF([attrib],[FUNC_]AS_TR_CPP($1))] dnl +)dnl +m4_ifval([$3], dnl + [AS_VAR_PUSHDEF([rbcv],[$3])], dnl + [AS_VAR_PUSHDEF([rbcv],[rb_cv_func_][$1])]dnl +)dnl +AC_CACHE_CHECK(for [$1] function attribute, rbcv, +[rbcv=x +if test "${ac_c_werror_flag+set}"; then + rb_c_werror_flag="$ac_c_werror_flag" +else + unset rb_c_werror_flag +fi +ac_c_werror_flag=yes +for mac in "__attribute__ (($1)) x" "x __attribute__ (($1))" "__declspec($1) x" x; do AC_TRY_COMPILE( - [#define NORETURN(x) $mac -NORETURN(void exit(int x));], - [], - [rb_cv_noreturn="$mac"; break]) -done]) -AC_DEFINE_UNQUOTED([NORETURN(x)], $rb_cv_noreturn) + [#define ]attrib[(x) $mac + ]attrib[(void conftest_attribute_check(void));], [], + [rbcv="$mac"; break]) +done +if test "${rb_c_werror_flag+set}"; then + ac_c_werror_flag="$rb_c_werror_flag" +else + unset ac_c_werror_flag +fi +]) +AC_DEFINE_UNQUOTED(attrib[(x)], $rbcv) +AS_VAR_POPDEF([attrib]) +AS_VAR_POPDEF([rbcv]) +]) + +RUBY_FUNC_ATTRIBUTE(noreturn, NORETURN) +RUBY_FUNC_ATTRIBUTE(noinline, NOINLINE) AC_CACHE_CHECK([for RUBY_EXTERN], rb_cv_ruby_extern, [rb_cv_ruby_extern=no @@ -595,6 +621,21 @@ AC_C_CHAR_UNSIGNED AC_C_INLINE AC_C_VOLATILE +if test x"$target_cpu" = xia64; then + AC_LIBOBJ([ia64]) + AC_CACHE_CHECK(for __libc_ia64_register_backing_store_base, + rb_cv___libc_ia64_register_backing_store_base, + [rb_cv___libc_ia64_register_backing_store_base=no + AC_TRY_LINK( + [extern unsigned long __libc_ia64_register_backing_store_base;], + [unsigned long p = __libc_ia64_register_backing_store_base; + printf("%ld\n", p);], + [rb_cv___libc_ia64_register_backing_store_base=yes])]) + if test $rb_cv___libc_ia64_register_backing_store_base = yes; then + AC_DEFINE(HAVE___LIBC_IA64_REGISTER_BACKING_STORE_BASE) + fi +fi + AC_CACHE_CHECK(whether right shift preserve sign bit, rb_cv_rshift_sign, [AC_TRY_RUN([ int @@ -827,7 +868,7 @@ if test x"$enable_pthread" = xyes; then fi fi if test x"$ac_cv_header_ucontext_h" = xyes; then - if test x"$target_cpu" = xia64 -o x"$rb_with_pthread" = xyes; then + if x"$rb_with_pthread" = xyes; then AC_CHECK_FUNCS(getcontext setcontext) fi fi diff --git a/defines.h b/defines.h index fb221da81d..b87ef0c8c5 100644 --- a/defines.h +++ b/defines.h @@ -221,13 +221,10 @@ flush_register_windows(void) ; } # define FLUSH_REGISTER_WINDOWS flush_register_windows() -#elif defined(__ia64__) -void flush_register_windows(void) -# if defined(__GNUC__) && (( __GNUC__ == 3 && __GNUC_MINOR__ > 0 ) || __GNUC__ > 3) -__attribute__ ((noinline)) -# endif - ; -# define FLUSH_REGISTER_WINDOWS flush_register_windows() +#elif defined(__ia64) +void *rb_ia64_bsp(void); +void rb_ia64_flushrs(void); +# define FLUSH_REGISTER_WINDOWS rb_ia64_flushrs() #else # define FLUSH_REGISTER_WINDOWS ((void)0) #endif diff --git a/eval.c b/eval.c index 506cf488ce..96bb66d78e 100644 --- a/eval.c +++ b/eval.c @@ -195,7 +195,8 @@ static int volatile freebsd_clear_carry_flag = 0; # define POST_GETCONTEXT 0 # endif # define ruby_longjmp(env, val) rb_jump_context(env, val) -# define ruby_setjmp(j) ((j)->status = 0, \ +# define ruby_setjmp(just_before_setjmp, j) ((j)->status = 0, \ + (just_before_setjmp), \ PRE_GETCONTEXT, \ getcontext(&(j)->context), \ POST_GETCONTEXT, \ @@ -203,10 +204,12 @@ static int volatile freebsd_clear_carry_flag = 0; #else typedef jmp_buf rb_jmpbuf_t; # if !defined(setjmp) && defined(HAVE__SETJMP) -# define ruby_setjmp(env) _setjmp(env) +# define ruby_setjmp(just_before_setjmp, env) \ + ((just_before_setjmp), _setjmp(env)) # define ruby_longjmp(env,val) _longjmp(env,val) # else -# define ruby_setjmp(env) setjmp(env) +# define ruby_setjmp(just_before_setjmp, env) \ + ((just_before_setjmp), setjmp(env)) # define ruby_longjmp(env,val) longjmp(env,val) # endif #endif @@ -1027,7 +1030,7 @@ static struct tag *prot_tag; #define PROT_LAMBDA INT2FIX(2) /* 5 */ #define PROT_YIELD INT2FIX(3) /* 7 */ -#define EXEC_TAG() (FLUSH_REGISTER_WINDOWS, ruby_setjmp(prot_tag->buf)) +#define EXEC_TAG() (FLUSH_REGISTER_WINDOWS, ruby_setjmp(((void)0), prot_tag->buf)) #define JUMP_TAG(st) do { \ ruby_frame = prot_tag->frame; \ @@ -9680,19 +9683,6 @@ Init_Binding() rb_define_global_function("binding", rb_f_binding, 0); } -#ifdef __ia64__ -#if defined(__FreeBSD__) -/* - * FreeBSD/ia64 currently does not have a way for a process to get the - * base address for the RSE backing store, so hardcode it. - */ -#define __libc_ia64_register_backing_store_base (4ULL<<61) -#else -#pragma weak __libc_ia64_register_backing_store_base -extern unsigned long __libc_ia64_register_backing_store_base; -#endif -#endif - /* Windows SEH refers data on the stack. */ #undef SAVE_WIN32_EXCEPTION_LIST #if defined _WIN32 || defined __CYGWIN__ @@ -9796,9 +9786,11 @@ struct thread { long stk_max; VALUE *stk_ptr; VALUE *stk_pos; -#ifdef __ia64__ - VALUE *bstr_ptr; +#ifdef __ia64 long bstr_len; + long bstr_max; + VALUE *bstr_ptr; + VALUE *bstr_pos; #endif struct FRAME *frame; @@ -10052,9 +10044,9 @@ thread_mark(th) #if defined(THINK_C) || defined(__human68k__) rb_gc_mark_locations(th->stk_ptr+2, th->stk_ptr+th->stk_len+2); #endif -#ifdef __ia64__ +#ifdef __ia64 if (th->bstr_ptr) { - rb_gc_mark_locations(th->bstr_ptr, th->bstr_ptr+th->bstr_len); + rb_gc_mark_locations(th->bstr_ptr, th->bstr_ptr+th->bstr_len); } #endif } @@ -10140,7 +10132,7 @@ thread_free(th) { if (th->stk_ptr) free(th->stk_ptr); th->stk_ptr = 0; -#ifdef __ia64__ +#ifdef __ia64 if (th->bstr_ptr) free(th->bstr_ptr); th->bstr_ptr = 0; #endif @@ -10180,6 +10172,9 @@ static char *th_signm; #define RESTORE_EXIT 7 extern VALUE *rb_gc_stack_start; +#ifdef __ia64 +extern VALUE *rb_gc_register_stack_start; +#endif static void rb_thread_save_context(th) @@ -10201,22 +10196,19 @@ rb_thread_save_context(th) th->stk_len = len; FLUSH_REGISTER_WINDOWS; MEMCPY(th->stk_ptr, th->stk_pos, VALUE, th->stk_len); -#ifdef __ia64__ - { - ucontext_t ctx; - VALUE *top, *bot; - - getcontext(&ctx); - bot = (VALUE*)__libc_ia64_register_backing_store_base; -#if defined(__FreeBSD__) - top = (VALUE*)ctx.uc_mcontext.mc_special.bspstore; -#else - top = (VALUE*)ctx.uc_mcontext.sc_ar_bsp; -#endif - th->bstr_len = top - bot; - REALLOC_N(th->bstr_ptr, VALUE, th->bstr_len); - MEMCPY(th->bstr_ptr, (VALUE*)__libc_ia64_register_backing_store_base, VALUE, th->bstr_len); - } +#ifdef __ia64 + th->bstr_pos = rb_gc_register_stack_start; + len = (VALUE*)rb_ia64_bsp() - th->bstr_pos; + th->bstr_len = 0; + if (len > th->bstr_max) { + VALUE *ptr = realloc(th->bstr_ptr, sizeof(VALUE) * len); + if (!ptr) rb_memerror(); + th->bstr_ptr = ptr; + th->bstr_max = len; + } + th->bstr_len = len; + rb_ia64_flushrs(); + MEMCPY(th->bstr_ptr, th->bstr_pos, VALUE, th->bstr_len); #endif #ifdef SAVE_WIN32_EXCEPTION_LIST th->win32_exception_list = win32_get_exception_list(); @@ -10289,52 +10281,19 @@ rb_thread_switch(n) } #define THREAD_SAVE_CONTEXT(th) \ - (rb_thread_save_context(th),\ - rb_thread_switch((FLUSH_REGISTER_WINDOWS, ruby_setjmp((th)->context)))) + (rb_thread_switch((FLUSH_REGISTER_WINDOWS, ruby_setjmp(rb_thread_save_context(th), (th)->context)))) NORETURN(static void rb_thread_restore_context _((rb_thread_t,int))); - -# if defined(_MSC_VER) && _MSC_VER >= 1300 -__declspec(noinline) static void stack_extend(rb_thread_t, int); -# endif -static void -stack_extend(th, exit) - rb_thread_t th; - int exit; -{ - VALUE space[1024]; - - memset(space, 0, 1); /* prevent array from optimization */ - rb_thread_restore_context(th, exit); -} +NORETURN(NOINLINE(static void rb_thread_restore_context_0(rb_thread_t,int,void*))); +NORETURN(NOINLINE(static void stack_extend(rb_thread_t, int, VALUE *))); static void -rb_thread_restore_context(th, exit) - rb_thread_t th; - int exit; +rb_thread_restore_context_0(rb_thread_t th, int exit, void *vp) { - VALUE v; static rb_thread_t tmp; static int ex; static VALUE tval; - if (!th->stk_ptr) rb_bug("unsaved context"); - -#if STACK_GROW_DIRECTION < 0 - if (&v > th->stk_pos) stack_extend(th, exit); -#elif STACK_GROW_DIRECTION > 0 - if (&v < th->stk_pos + th->stk_len) stack_extend(th, exit); -#else - if (&v < rb_gc_stack_start) { - /* Stack grows downward */ - if (&v > th->stk_pos) stack_extend(th, exit); - } - else { - /* Stack grows upward */ - if (&v < th->stk_pos + th->stk_len) stack_extend(th, exit); - } -#endif - rb_trap_immediate = 0; /* inhibit interrupts from here */ ruby_frame = th->frame; ruby_scope = th->scope; @@ -10360,8 +10319,8 @@ rb_thread_restore_context(th, exit) ex = exit; FLUSH_REGISTER_WINDOWS; MEMCPY(tmp->stk_pos, tmp->stk_ptr, VALUE, tmp->stk_len); -#ifdef __ia64__ - MEMCPY((VALUE*)__libc_ia64_register_backing_store_base, tmp->bstr_ptr, VALUE, tmp->bstr_len); +#ifdef __ia64 + MEMCPY(tmp->bstr_pos, tmp->bstr_ptr, VALUE, tmp->bstr_len); #endif tval = rb_lastline_get(); @@ -10374,6 +10333,78 @@ rb_thread_restore_context(th, exit) ruby_longjmp(tmp->context, ex); } +#ifdef __ia64 +#define C(a) rse_##a##0, rse_##a##1, rse_##a##2, rse_##a##3, rse_##a##4 +#define E(a) rse_##a##0= rse_##a##1= rse_##a##2= rse_##a##3= rse_##a##4 +static volatile int C(a), C(b), C(c), C(d), C(e); +static volatile int C(f), C(g), C(h), C(i), C(j); +static volatile int C(k), C(l), C(m), C(n), C(o); +static volatile int C(p), C(q), C(r), C(s), C(t); +int rb_dummy_false = 0; +NORETURN(NOINLINE(static void register_stack_extend(rb_thread_t, int, void *, VALUE *))); +static void +register_stack_extend(rb_thread_t th, int exit, void *vp, VALUE *curr_bsp) +{ + if (rb_dummy_false) { + /* use registers as much as possible */ + E(a) = E(b) = E(c) = E(d) = E(e) = + E(f) = E(g) = E(h) = E(i) = E(j) = + E(k) = E(l) = E(m) = E(n) = E(o) = + E(p) = E(q) = E(r) = E(s) = E(t) = 0; + E(a) = E(b) = E(c) = E(d) = E(e) = + E(f) = E(g) = E(h) = E(i) = E(j) = + E(k) = E(l) = E(m) = E(n) = E(o) = + E(p) = E(q) = E(r) = E(s) = E(t) = 0; + } + if (curr_bsp < th->bstr_pos+th->bstr_len) { + register_stack_extend(th, exit, &exit, (VALUE*)rb_ia64_bsp()); + } + rb_thread_restore_context_0(th, exit, &exit); +} +#undef C +#undef E +#endif + +# if defined(_MSC_VER) && _MSC_VER >= 1300 +__declspec(noinline) static void stack_extend(rb_thread_t, int); +# endif +static void +stack_extend(rb_thread_t th, int exit, VALUE *addr_in_prev_frame) +{ +#define STACK_PAD_SIZE 1024 + VALUE space[STACK_PAD_SIZE]; + +#if STACK_GROW_DIRECTION < 0 + if (addr_in_prev_frame > th->stk_pos) stack_extend(th, exit, &space[0]); +#elif STACK_GROW_DIRECTION > 0 + if (addr_in_prev_frame < th->stk_pos + th->stk_len) stack_extend(th, exit, &space[STACK_PAD_SIZE-1]); +#else + if (addr_in_prev_frame < rb_gc_stack_start) { + /* Stack grows downward */ + if (addr_in_prev_frame > th->stk_pos) stack_extend(th, exit, &space[0]); + } + else { + /* Stack grows upward */ + if (addr_in_prev_frame < th->stk_pos + th->stk_len) stack_extend(th, exit, &space[STACK_PAD_SIZE-1]); + } +#endif +#ifdef __ia64 + register_stack_extend(th, exit, space, (VALUE*)rb_ia64_bsp()); +#else + rb_thread_restore_context_0(th, exit, space); +#endif +} + +static void +rb_thread_restore_context(th, exit) + rb_thread_t th; + int exit; +{ + VALUE v; + if (!th->stk_ptr) rb_bug("unsaved context"); + stack_extend(th, exit, &v); +} + static void rb_thread_ready(th) rb_thread_t th; @@ -11579,7 +11610,7 @@ rb_thread_group(thread) return group; } -#ifdef __ia64__ +#ifdef __ia64 # define IA64_INIT(x) x #else # define IA64_INIT(x) @@ -11601,6 +11632,7 @@ rb_thread_group(thread) th->wait_for = 0;\ IA64_INIT(th->bstr_ptr = 0);\ IA64_INIT(th->bstr_len = 0);\ + IA64_INIT(th->bstr_max = 0);\ FD_ZERO(&th->readfds);\ FD_ZERO(&th->writefds);\ FD_ZERO(&th->exceptfds);\ @@ -13054,13 +13086,3 @@ rb_throw(tag, val) argv[1] = val; rb_f_throw(2, argv); } - -/* flush_register_windows must not be inlined because flushrs doesn't flush - * current frame in register stack. */ -#ifdef __ia64__ -void flush_register_windows(void) -{ - __asm__ ("flushrs"); -} -#endif - diff --git a/gc.c b/gc.c index c69afef2b5..ccfa68b23d 100644 --- a/gc.c +++ b/gc.c @@ -30,20 +30,6 @@ #include #endif -#ifdef __ia64__ -#include -#if defined(__FreeBSD__) -/* - * FreeBSD/ia64 currently does not have a way for a process to get the - * base address for the RSE backing store, so hardcode it. - */ -#define __libc_ia64_register_backing_store_base (4ULL<<61) -#else -#pragma weak __libc_ia64_register_backing_store_base -extern unsigned long __libc_ia64_register_backing_store_base; -#endif -#endif - #if defined _WIN32 || defined __CYGWIN__ #include #endif @@ -423,6 +409,9 @@ rb_data_object_alloc(klass, datap, dmark, dfree) extern st_table *rb_class_tbl; VALUE *rb_gc_stack_start = 0; +#ifdef __ia64 +VALUE *rb_gc_register_stack_start = 0; +#endif #ifdef DJGPP /* set stack size (http://www.delorie.com/djgpp/v2faq/faq15_9.html) */ @@ -445,7 +434,7 @@ static unsigned int STACK_LEVEL_MAX = 655300; # define SET_STACK_END VALUE stack_end; alloca(0); # define STACK_END (&stack_end) #else -# if defined(__GNUC__) && defined(USE_BUILTIN_FRAME_ADDRESS) && !defined(__ia64__) +# if defined(__GNUC__) && defined(USE_BUILTIN_FRAME_ADDRESS) && !defined(__ia64) # if ( __GNUC__ == 3 && __GNUC_MINOR__ > 0 ) || __GNUC__ > 3 __attribute__ ((noinline)) # endif @@ -1385,23 +1374,10 @@ garbage_collect() else rb_gc_mark_locations(rb_gc_stack_start, (VALUE*)STACK_END + 1); #endif -#ifdef __ia64__ +#ifdef __ia64 /* mark backing store (flushed register window on the stack) */ /* the basic idea from guile GC code */ - { - ucontext_t ctx; - VALUE *top, *bot; - getcontext(&ctx); - mark_locations_array((VALUE*)&ctx.uc_mcontext, - ((size_t)(sizeof(VALUE)-1 + sizeof ctx.uc_mcontext)/sizeof(VALUE))); - bot = (VALUE*)__libc_ia64_register_backing_store_base; -#if defined(__FreeBSD__) - top = (VALUE*)ctx.uc_mcontext.mc_special.bspstore; -#else - top = (VALUE*)ctx.uc_mcontext.sc_ar_bsp; -#endif - rb_gc_mark_locations(bot, top); - } + rb_gc_mark_locations(rb_gc_register_stack_start, (VALUE*)rb_ia64_bsp()); #endif #if defined(__human68k__) || defined(__mc68000__) rb_gc_mark_locations((VALUE*)((char*)STACK_END + 2), @@ -1477,6 +1453,28 @@ void Init_stack(addr) VALUE *addr; { +#ifdef __ia64 + if (rb_gc_register_stack_start == 0) { +# if defined(__FreeBSD__) + /* + * FreeBSD/ia64 currently does not have a way for a process to get the + * base address for the RSE backing store, so hardcode it. + */ + rb_gc_register_stack_start = (4ULL<<61); +# elif defined(HAVE___LIBC_IA64_REGISTER_BACKING_STORE_BASE) +# pragma weak __libc_ia64_register_backing_store_base + extern unsigned long __libc_ia64_register_backing_store_base; + rb_gc_register_stack_start = (VALUE*)__libc_ia64_register_backing_store_base; +# endif + } + { + VALUE *bsp = (VALUE*)rb_ia64_bsp(); + if (rb_gc_register_stack_start == 0 || + bsp < rb_gc_register_stack_start) { + rb_gc_register_stack_start = bsp; + } + } +#endif #if defined(_WIN32) || defined(__CYGWIN__) MEMORY_BASIC_INFORMATION m; memset(&m, 0, sizeof(m)); @@ -1485,8 +1483,10 @@ Init_stack(addr) STACK_UPPER((VALUE *)&m, (VALUE *)m.BaseAddress, (VALUE *)((char *)m.BaseAddress + m.RegionSize) - 1); #elif defined(STACK_END_ADDRESS) - extern void *STACK_END_ADDRESS; - rb_gc_stack_start = STACK_END_ADDRESS; + { + extern void *STACK_END_ADDRESS; + rb_gc_stack_start = STACK_END_ADDRESS; + } #else if (!addr) addr = (VALUE *)&addr; STACK_UPPER(&addr, addr, ++addr); @@ -1513,6 +1513,37 @@ Init_stack(addr) #endif } +void ruby_init_stack(VALUE *addr +#ifdef __ia64 + , void *bsp +#endif + ) +{ + if (!rb_gc_stack_start || + STACK_UPPER(&addr, + rb_gc_stack_start > addr, + rb_gc_stack_start < addr)) { + rb_gc_stack_start = addr; + } +#ifdef __ia64 + if (!rb_gc_register_stack_start || + (VALUE*)bsp < rb_gc_register_stack_start) { + rb_gc_register_stack_start = (VALUE*)bsp; + } +#endif +#ifdef HAVE_GETRLIMIT + { + struct rlimit rlim; + + if (getrlimit(RLIMIT_STACK, &rlim) == 0) { + unsigned int space = rlim.rlim_cur/5; + + if (space > 1024*1024) space = 1024*1024; + STACK_LEVEL_MAX = (rlim.rlim_cur - space) / sizeof(VALUE); + } + } +#endif +} /* * Document-class: ObjectSpace diff --git a/main.c b/main.c index 9fe389cfe0..bee9a4b15b 100644 --- a/main.c +++ b/main.c @@ -41,8 +41,11 @@ main(argc, argv, envp) argc = ccommand(&argv); #endif - ruby_init(); - ruby_options(argc, argv); - ruby_run(); + { + RUBY_INIT_STACK + ruby_init(); + ruby_options(argc, argv); + ruby_run(); + } return 0; } diff --git a/numeric.c b/numeric.c index a937868ce4..f6f1d3b22b 100644 --- a/numeric.c +++ b/numeric.c @@ -2042,6 +2042,10 @@ fix_mul(x, y) VALUE x, y; { if (FIXNUM_P(y)) { +#ifdef __HP_cc + /* avoids an optimization bug of HP aC++/ANSI C B3910B A.06.05 [Jul 25 2005] */ + volatile +#endif long a, b, c; VALUE r; diff --git a/ruby.h b/ruby.h index dcf7fbd822..0a75902b87 100644 --- a/ruby.h +++ b/ruby.h @@ -25,6 +25,15 @@ extern "C" { #ifdef RUBY_EXTCONF_H #include RUBY_EXTCONF_H #endif + +#define NORETURN_STYLE_NEW 1 +#ifndef NORETURN +# define NORETURN(x) x +#endif +#ifndef NOINLINE +# define NOINLINE(x) x +#endif + #include "defines.h" #ifdef HAVE_STDLIB_H @@ -58,11 +67,6 @@ extern "C" { #define ISXDIGIT(c) (ISASCII(c) && isxdigit((int)(unsigned char)(c))) #endif -#define NORETURN_STYLE_NEW 1 -#ifndef NORETURN -# define NORETURN(x) x -#endif - #if defined(HAVE_ALLOCA_H) #include #else @@ -565,6 +569,17 @@ NORETURN(void rb_throw _((const char*,VALUE))); VALUE rb_require _((const char*)); +#ifdef __ia64 +void ruby_init_stack(VALUE*, void*); +#define RUBY_INIT_STACK \ + VALUE variable_in_this_stack_frame; \ + ruby_init_stack(&variable_in_this_stack_frame, rb_ia64_bsp()); +#else +void ruby_init_stack(VALUE*); +#define RUBY_INIT_STACK \ + VALUE variable_in_this_stack_frame; \ + ruby_init_stack(&variable_in_this_stack_frame); +#endif void ruby_init _((void)); void ruby_options _((int, char**)); NORETURN(void ruby_run _((void)));