bug in gcse, gcc-2.95 generates wrong code
Bruno Haible
haible@ilog.fr
Tue Jul 6 13:32:00 GMT 1999
Hello,
This looks like a serious bug in GCSE: it moves around a memory access
to a different basic block, to a point where it causes a segmentation fault.
The gcc in use is gcc-2.95 19990623 (prerelease), configured for
sparc-sun-solaris2.6.
Appended are the source file, bug.c, and the compilation result:
$ gcc -O2 -S bug.c -o bug.s.buggy
bug.c:112: warning: volatile register variables don't work as you might wish
bug.c:167: warning: call-clobbered register used for global register variable
$ gcc -O2 -fno-gcse -S bug.c -o bug.s.ok
bug.c:112: warning: volatile register variables don't work as you might wish
bug.c:167: warning: call-clobbered register used for global register variable
$ gcc -v
Reading specs from /nfs/telecom/users/haible/gnu/arch/solaris/lib/gcc-lib/sparc-sun-solaris2.6/gcc-2.95/specs
gcc version gcc-2.95 19990623 (prerelease)
The problem occurs in a conditional expression, right after the call to
`sym_function':
if (!((((oint)value1 & 3) == 2)
|| ((((oint)value1 & 3) == 1)
&& (((sintB)((((Record)((oint)value1 - 1)))->tfl & 0xFF)) == Rectype_Closure))
|| ((((oint)value1 & 3) == 1)
&& (((sintB)((((Record)((oint)value1 - 1)))->tfl & 0xFF)) == Rectype_Ffunction))))
The code generated is as follows (value1 is %g7):
and %g7, 3, %o0
cmp %o0, 2
be .LL23
cmp %o0, 1
ldub [%g7+6], %o1 ;; load the ->tfl byte from memory, too early
bne .LL24
mov %o0, %o2
ldsb [%g7+6], %o0
cmp %o0, -3
be,a .LL83
mov 1, %g6
.LL24:
cmp %o2, 1
bne .LL84
add %l2, 420, %o0
cmp %o1, 32 ;; use it here
be,a .LL83
mov 1, %g6
.LL84:
call fehler_undef_function, 0
mov %l0, %o1
.LL23:
mov 1, %g6
.LL83:
The problem with the generated code is that the load instruction occurs in
the branch where %o0 = ((oint)value1 & 3) is != 2. But the C code requests
the memory access only if %o0 = ((oint)value1 & 3) is 1. If it is 0 or 3,
the conditional expression ought to return FALSE without memory access.
The extra memory access inserted by gcc's gcse causes the function to dump
core.
Regards,
Bruno
=============================== bug.c ======================================
typedef char SBYTE;
typedef unsigned char UBYTE;
typedef short SWORD;
typedef unsigned short UWORD;
typedef long SLONG;
typedef unsigned long ULONG;
typedef unsigned int boolean;
typedef UBYTE uint8;
typedef SBYTE sint8;
typedef UWORD uint16;
typedef SWORD sint16;
typedef ULONG uint32;
typedef SLONG sint32;
typedef sint8 sintB;
typedef uint8 uintB;
typedef sint16 sintW;
typedef uint16 uintW;
typedef sint32 sintL;
typedef uint32 uintL;
typedef sint32 sintP;
typedef uint32 uintP;
typedef sint32 sintWL;
typedef uint32 uintWL;
typedef void * object;
typedef uintL oint;
typedef sintL soint;
typedef uint8 tint;
typedef uint32 aint;
typedef struct { object GCself; uintL tfl;
object recdata[0 ];
}
record_;
typedef record_ * Record;
enum {
enum_rectype_first = -4,
Rectype_Closure,
Rectype_Structure,
Rectype_Instance,
rectype_limit,
Rectype_Hashtable = rectype_limit,
Rectype_vector,
Rectype_bvector,
Rectype_Sbvector,
rectype_unused1,
Rectype_Svector,
Rectype_Sstring,
Rectype_Imm_Sstring,
Rectype_Imm_SmallSstring,
Rectype_string,
Rectype_mdarray,
Rectype_Bignum,
Rectype_Lfloat,
Rectype_Dfloat,
Rectype_Ffloat,
Rectype_Ratio,
Rectype_Complex,
Rectype_Symbol,
Rectype_Package,
Rectype_Readtable,
Rectype_Pathname,
Rectype_Logpathname,
Rectype_Random_State,
Rectype_Stream,
Rectype_Byte,
Rectype_Fsubr,
Rectype_Loadtimeeval,
Rectype_Symbolmacro,
Rectype_Encoding,
Rectype_Fpointer,
Rectype_Faddress,
Rectype_Fvariable,
Rectype_Ffunction,
Rectype_Weakpointer,
Rectype_Finalizer,
Rectype_Socket_Server,
rectype_for_broken_compilers_that_dont_like_trailing_commas
};
typedef struct { object cdr;
object car;
}
cons_;
typedef cons_ * Cons;
typedef struct { object GCself; uintL tfl;
object symvalue;
object symfunction;
object proplist;
object pname;
object homepackage;
}
symbol_;
typedef struct { object GCself; uintL tfl;
object data;
uintL totalsize;
uintL dims[0 ];
}
iarray_;
typedef iarray_ * Iarray;
typedef void Values;
typedef Values (*lisp_function)();
typedef struct { lisp_function function;
object name;
object keywords;
uintW argtype;
uintW req_anz;
uintW opt_anz;
uintB rest_flag;
uintB key_flag;
uintW key_anz;
}
subr_;
typedef subr_ * Subr;
register __volatile__ aint __SP __asm__("%sp" );
register object* STACK __asm__("%g5" );
extern const char * clgettext (const char * msgid);
extern object allocate_cons (void);
typedef Values subr_norest_function (void);
extern subr_norest_function C_coerce;
extern struct subr_tab_ {
subr_ D_coerce;
subr_ D_copy_seq;
subr_ D_realpart;
subr_ D_imagpart;
subr_ D_complex;
}
subr_tab_data;
extern struct symbol_tab_ {
symbol_ S_nil;
symbol_ S_t;
symbol_ S_deftype_expander;
symbol_ S_base_char;
symbol_ S_string_char;
symbol_ S_character;
symbol_ S_typep;
symbol_ S_float;
symbol_ S_short_float;
symbol_ S_single_float;
symbol_ S_double_float;
symbol_ S_long_float;
symbol_ S_complex;
symbol_ S_number;
symbol_ S_function;
symbol_ S_lambda;
symbol_ S_Klambda;
symbol_ S_coerce;
symbol_ S_array;
symbol_ S_simple_array;
symbol_ S_vector;
symbol_ S_simple_vector;
symbol_ S_bit_vector;
symbol_ S_simple_bit_vector;
symbol_ S_string;
symbol_ S_simple_string;
symbol_ S_base_string;
symbol_ S_simple_base_string;
symbol_ S_and;
symbol_ S_mal;
}
symbol_tab_data;
extern struct object_tab_ {
object type_designator_character;
object type_designator_function;
object top_decl_env;
}
object_tab;
register uintWL mv_count __asm__("%g6" );
register object value1 __asm__("%g7" );
register object subr_self __asm__("%g4" );
typedef struct { object var_env;
object fun_env;
object block_env;
object go_env;
object decl_env;
}
environment;
extern Values funcall (object fun, uintWL argcount);
extern boolean funnamep (object obj);
extern object sym_function (object sym, object fenv);
extern object get_closure (object lambdabody, object name, boolean blockp, environment* env);
extern object coerce_function (object obj);
extern void fehler_undef_function (object caller, object symbol) __attribute__((__noreturn__));
extern object array_element_type (object array);
extern object coerce_ss (object obj);
extern object coerce_imm_ss (object obj);
extern object coerce_normal_ss (object obj);
extern object coerce_char (object obj);
typedef enum
{
condition,
serious_condition,
error,
program_error,
source_program_error,
control_error,
arithmetic_error,
division_by_zero,
floating_point_overflow,
floating_point_underflow,
cell_error,
unbound_variable,
undefined_function,
unbound_slot,
type_error,
keyword_error,
charset_type_error,
package_error,
print_not_readable,
parse_error,
stream_error,
end_of_file,
reader_error,
file_error,
os_error,
storage_condition,
warning,
condition_for_broken_compilers_that_dont_like_trailing_commas
}
conditiontype;
extern void fehler (conditiontype errortype, const char * errorstring) __attribute__((__noreturn__));
extern Values coerce_sequence (object sequence, object result_type);
extern object get (object symbol, object key);
extern object coerce_float (object obj, object type);
Values C_coerce (void)
{
(STACK[0] = (STACK[-2]), STACK -= -1);
(STACK[0] = STACK[-2], STACK -= -1);
funcall(((object)((UBYTE*)(&symbol_tab_data.S_typep)+1)),2);
if (!((value1 == (((object)((UBYTE*)(&symbol_tab_data.S_nil)+1))))))
return_object:
{
value1 = STACK[-2];
mv_count=1;
(STACK -= 2);
return;
}
anfang:
if ((!(((oint)STACK[-1] & 7) == 3)))
{
if (!((((oint)STACK[-1] & 3) == 1) && (((sintB)((((Record)((oint)STACK[-1] - 1)))->tfl & 0xFF)) == Rectype_Symbol)))
goto fehler_type;
{
object result_type = STACK[-1];
{
object expander = get(result_type,((object)((UBYTE*)(&symbol_tab_data.S_deftype_expander)+1)));
if (!((expander) == (((object)(((oint)(tint)(((7 << 3) + 7)) << 0) + ((oint)(aint)((1L<<(24 -1)) | (1L<<(0)) | (((2L<<((24)-1)) -1) & (0xFFFFFFUL))) << 7))))))
{
(STACK[0] = (expander), STACK -= -1);
{
object new_cons = allocate_cons();
expander = (STACK -= 1, STACK[0]);
(((Cons)((oint)(new_cons) - 3)) ->car) = STACK[-1];
(STACK[0] = (new_cons), STACK -= -1);
funcall(expander,1);
STACK[-1] = value1;
goto anfang;
}
}
}
if (((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_t)+1)))))
goto return_object;
if (((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_character)+1)))) || ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_string_char)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_base_char)+1))))
)
{
object as_char = coerce_char(STACK[-2]);
if ((((as_char) == (((object)((UBYTE*)(&symbol_tab_data.S_nil)+1))))))
{
(STACK[0] = (STACK[-2]), STACK -= -1);
(STACK[0] = ((object_tab. type_designator_character)), STACK -= -1);
goto fehler_object;
}
value1 = as_char;
mv_count=1;
(STACK -= 2);
return;
}
if (((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_float)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_short_float)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_single_float)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_double_float)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_long_float)+1))))
)
{
subr_self = (object)((oint)(& subr_tab_data .D_coerce)+2);
value1 = coerce_float(STACK[-2],result_type);
mv_count=1;
(STACK -= 2);
return;
}
if (((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_complex)+1)))))
{
if (!((((oint)(STACK[-2]) & ((4 << 3) | 7)) == (((0 << 3) + 7) & ((2 << 3) + 7))) || ((((oint)(STACK[-2]) & 3) == 1) && ((uintB)(((sintB)((((Record)((oint)(STACK[-2]) - 1)))->tfl & 0xFF)) -Rectype_Bignum) <= Rectype_Complex-Rectype_Bignum))))
{
(STACK[0] = (STACK[-2]), STACK -= -1);
(STACK[0] = (((object)((UBYTE*)(&symbol_tab_data.S_number)+1))), STACK -= -1);
goto fehler_object;
}
goto return_object;
}
if (((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_function)+1)))))
{
object fun = STACK[-2];
if (funnamep(fun))
{
value1 = sym_function(fun,((object)((UBYTE*)(&symbol_tab_data.S_nil)+1)));
if (!((((oint)value1 & 3) == 2)
|| ((((oint)value1 & 3) == 1) && (((sintB)((((Record)((oint)value1 - 1)))->tfl & 0xFF)) == Rectype_Closure))
|| ((((oint)value1 & 3) == 1) && (((sintB)((((Record)((oint)value1 - 1)))->tfl & 0xFF)) == Rectype_Ffunction))))
{
fehler_undef_function(((object)((UBYTE*)(&symbol_tab_data.S_coerce)+1)),fun);
}
mv_count=1;
(STACK -= 2);
return;
}
if (!((((oint)fun & 7) == 3) && (((((Cons)((oint)fun - 3)) ->car)) == (((object)((UBYTE*)(&symbol_tab_data.S_lambda)+1))))))
{
(STACK[0] = fun, STACK -= -1);
(STACK[0] = ((object_tab. type_designator_function)), STACK -= -1);
goto fehler_object;
}
{
environment* env;
{
(STACK[0] = (((object)((UBYTE*)(&symbol_tab_data.S_nil)+1))), STACK -= -1);
(STACK[0] = (((object)((UBYTE*)(&symbol_tab_data.S_nil)+1))), STACK -= -1);
(STACK[0] = (((object)((UBYTE*)(&symbol_tab_data.S_nil)+1))), STACK -= -1);
(STACK[0] = (((object)((UBYTE*)(&symbol_tab_data.S_nil)+1))), STACK -= -1);
(STACK[0] = ((object_tab. top_decl_env)), STACK -= -1); env = & (((environment *)STACK)[-1]);
};
value1 = get_closure((((Cons)((oint)fun - 3)) ->cdr),((object)((UBYTE*)(&symbol_tab_data.S_Klambda)+1)),0,env); mv_count=1;
(STACK -= 7);
return;
}
}
if (((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_array)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_array)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_vector)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_vector)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_string)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_string)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_base_string)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_base_string)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_bit_vector)+1))))
|| ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_bit_vector)+1))))
)
{
if (((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_array)+1)))) || ((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_vector)+1)))))
{
if (((((oint)(STACK[-2]) & 3) == 1) && ((uintB)(((sintB)((((Record)((oint)(STACK[-2]) - 1)))->tfl & 0xFF)) - 6) <= 9-6)))
goto return_object;
else
if (((((oint)(STACK[-2]) & 3) == 1) && ((((sintB)((((Record)((oint)(STACK[-2]) - 1)) )->tfl & 0xFF)) == Rectype_Sbvector) || ((((sintB)((((Record)((oint)(STACK[-2]) - 1)))->tfl & 0xFF)) == Rectype_bvector) && (((((((Iarray)((oint)(STACK[-2]) - 1)))->tfl >> 8) & 0xFF) & 0x07) == 0)))))
goto return_object;
}
else
if (((result_type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_array)+1)))))
{
if (((((oint)(STACK[-2]) & 3) == 1) && ((uintB)(((sintB)((((Record)((oint)(STACK[-2]) - 1)))->tfl & 0xFF)) - 6) <= 9-6)))
{
result_type = ((object)((UBYTE*)(&symbol_tab_data.S_simple_string)+1));
}
else
if (((((oint)(STACK[-2]) & 3) == 1) && ((((sintB)((((Record)((oint)(STACK[-2]) - 1)) )->tfl & 0xFF)) == Rectype_Sbvector) || ((((sintB)((((Record)((oint)(STACK[-2]) - 1)))->tfl & 0xFF)) == Rectype_bvector) && (((((((Iarray)((oint)(STACK[-2]) - 1)))->tfl >> 8) & 0xFF) & 0x07) == 0)))))
{
result_type = ((object)((UBYTE*)(&symbol_tab_data.S_simple_bit_vector)+1));
}
}
(STACK[0] = (result_type), STACK -= -1);
{
object new_seq = (coerce_sequence(STACK[-3],result_type),value1);
(STACK[0] = (new_seq), STACK -= -1);
(STACK[0] = STACK[-2], STACK -= -1);
STACK[-3] = new_seq;
funcall(((object)((UBYTE*)(&symbol_tab_data.S_typep)+1)),2);
if (!((value1 == (((object)((UBYTE*)(&symbol_tab_data.S_nil)+1))))))
{
value1 = STACK[-1];
mv_count=1;
(STACK -= 3);
return;
}
else
{
funcall((object)((oint)(& subr_tab_data .D_copy_seq)+2),1);
(STACK -= 2);
return;
}
}
}
coerce_sequence(STACK[-2],result_type);
(STACK -= 2);
return;
}
}
else
{
object result_type = STACK[-1];
object type = (((Cons)((oint)(result_type) - 3)) ->car);
if (!((((oint)(type) & 3) == 1) && (((sintB)((((Record)((oint)(type) - 1)))->tfl & 0xFF)) == Rectype_Symbol)))
goto fehler_type;
if (((type) == (((object)((UBYTE*)(&symbol_tab_data.S_and)+1)))))
{
if ((!(((oint)((((Cons)((oint)(result_type) - 3)) ->cdr)) & 7) == 3)))
goto return_object;
(STACK[0] = (STACK[-2]), STACK -= -1);
(STACK[0] = ((((Cons)((oint)((((Cons)((oint)(result_type) - 3)) ->cdr)) - 3)) ->car)), STACK -= -1);
funcall((object)((oint)(& subr_tab_data .D_coerce)+2),2);
check_return:
(STACK[0] = value1, STACK -= -1);
(STACK[0] = value1, STACK -= -1);
(STACK[0] = STACK[-3], STACK -= -1);
funcall(((object)((UBYTE*)(&symbol_tab_data.S_typep)+1)),2);
if (((value1 == (((object)((UBYTE*)(&symbol_tab_data.S_nil)+1))))))
{
(STACK[0] = STACK[-2], STACK -= -1);
goto fehler_object;
}
else
{
value1 = STACK[-1];
mv_count=1;
(STACK -= 3);
return;
}
}
{
object expander = get(type,((object)((UBYTE*)(&symbol_tab_data.S_deftype_expander)+1)));
if (!((expander) == (((object)(((oint)(tint)(((7 << 3) + 7)) << 0) + ((oint)(aint)((1L<<(24 -1)) | (1L<<(0)) | (((2L<<((24)-1)) -1) & (0xFFFFFFUL))) << 7))))))
{
(STACK[0] = (result_type), STACK -= -1);
funcall(expander,1);
STACK[-1] = value1;
goto anfang;
}
}
if (((type) == (((object)((UBYTE*)(&symbol_tab_data.S_float)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_short_float)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_single_float)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_double_float)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_long_float)+1))))
)
{
subr_self = (object)((oint)(& subr_tab_data .D_coerce)+2);
value1 = coerce_float(STACK[-2],result_type);
goto check_return;
}
if (((type) == (((object)((UBYTE*)(&symbol_tab_data.S_complex)+1)))))
{
if (!((((oint)(STACK[-2]) & ((4 << 3) | 7)) == (((0 << 3) + 7) & ((2 << 3) + 7))) || ((((oint)(STACK[-2]) & 3) == 1) && ((uintB)(((sintB)((((Record)((oint)(STACK[-2]) - 1)))->tfl & 0xFF)) -Rectype_Bignum) <= Rectype_Complex-Rectype_Bignum))))
{
(STACK[0] = (STACK[-2]), STACK -= -1);
(STACK[0] = (((object)((UBYTE*)(&symbol_tab_data.S_number)+1))), STACK -= -1);
goto fehler_object;
}
if (!(((oint)((((Cons)((oint)(result_type) - 3)) ->cdr)) & 7) == 3))
goto fehler_type;
result_type = (((Cons)((oint)(result_type) - 3)) ->cdr);
{
object rtype = (((Cons)((oint)(result_type) - 3)) ->car);
object itype = ((((oint)((((Cons)((oint)(result_type) - 3)) ->cdr)) & 7) == 3) ? (((Cons)((oint)((((Cons)((oint)(result_type) - 3)) ->cdr)) - 3)) ->car) : rtype);
(STACK[0] = (rtype), STACK -= -1);
(STACK[0] = (itype), STACK -= -1);
(STACK[0] = STACK[-4], STACK -= -1);
funcall((object)((oint)(& subr_tab_data .D_realpart)+2),1);
(STACK[0] = value1, STACK -= -1);
(STACK[0] = STACK[-3], STACK -= -1);
funcall((object)((oint)(& subr_tab_data .D_coerce)+2),2);
STACK[-2] = value1;
(STACK[0] = STACK[-4], STACK -= -1);
funcall((object)((oint)(& subr_tab_data .D_imagpart)+2),1);
(STACK[0] = value1, STACK -= -1);
(STACK[0] = STACK[-2], STACK -= -1);
funcall((object)((oint)(& subr_tab_data .D_coerce)+2),2);
STACK[-1] = value1;
funcall((object)((oint)(& subr_tab_data .D_complex)+2),2);
(STACK -= 2);
return;
}
}
if (((type) == (((object)((UBYTE*)(&symbol_tab_data.S_array)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_array)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_vector)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_vector)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_string)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_string)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_base_string)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_base_string)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_bit_vector)+1))))
|| ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_bit_vector)+1))))
)
{
if (((type) == (((object)((UBYTE*)(&symbol_tab_data.S_array )+1)) )) || ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_simple_array)+1)))) || ((type) == (((object)((UBYTE*)(&symbol_tab_data.S_vector)+1)))))
{
object type2 = (((Cons)((oint)(result_type) - 3)) ->cdr);
if ((((type2) == (((object)((UBYTE*)(&symbol_tab_data.S_nil)+1))))))
goto adjust_eltype;
if (!(((oint)(type2) & 7) == 3))
goto fehler_type;
if ((((((Cons)((oint)(type2) - 3)) ->car)) == (((object)((UBYTE*)(&symbol_tab_data.S_mal)+1)))))
{
type2 = (((Cons)((oint)(type2) - 3)) ->cdr);
adjust_eltype:
(STACK[0] = (type), STACK -= -1);
(STACK[0] = (type2), STACK -= -1);
if (((((oint)STACK[-4] & 3) == 1) && ((uintB)(((sintB)((((Record)((oint)STACK[-4] - 1)))->tfl & 0xFF)) -1) <= 10-1)))
{
(STACK[0] = array_element_type(STACK[-4]), STACK -= -1);
}
else
{
(STACK[0] = (((object)((UBYTE*)(&symbol_tab_data.S_t)+1))), STACK -= -1);
}
{
object new_cons = allocate_cons();
(((Cons)((oint)(new_cons) - 3)) ->car) = (STACK -= 1, STACK[0]);
(((Cons)((oint)(new_cons) - 3)) ->cdr) = (STACK -= 1, STACK[0]);
(STACK[0] = (new_cons), STACK -= -1);
}
{
object new_cons = allocate_cons();
(((Cons)((oint)(new_cons) - 3)) ->cdr) = (STACK -= 1, STACK[0]);
(((Cons)((oint)(new_cons) - 3)) ->car) = type = (STACK -= 1, STACK[0]);
result_type = new_cons;
}
}
}
(STACK[0] = (type), STACK -= -1);
{
object new_seq = (coerce_sequence(STACK[-3],result_type),value1);
(STACK[0] = (new_seq), STACK -= -1);
(STACK[0] = STACK[-2], STACK -= -1);
STACK[-3] = new_seq;
funcall(((object)((UBYTE*)(&symbol_tab_data.S_typep)+1)),2);
if (!((value1 == (((object)((UBYTE*)(&symbol_tab_data.S_nil)+1))))))
{
value1 = (STACK -= 1, STACK[0]);
}
else
{
funcall((object)((oint)(& subr_tab_data .D_copy_seq)+2),1);
}
goto check_return;
}
}
}
fehler_type:
(STACK[0] = (((object)((UBYTE*)(&symbol_tab_data.S_coerce)+1))), STACK -= -1);
fehler(error,clgettext ("~: bad type specification ~"));
fehler_object:
(STACK[0] = STACK[-3], STACK -= -1);
(STACK[0] = STACK[-5], STACK -= -1);
(STACK[0] = (((object)((UBYTE*)(&symbol_tab_data.S_coerce)+1))), STACK -= -1);
fehler(type_error,clgettext ("~: ~ cannot be coerced to type ~"));
}
=============================== bug.s.buggy ================================
.file "bug.c"
gcc2_compiled.:
.section ".rodata"
.align 8
.LLC0:
.asciz "~: bad type specification ~"
.align 8
.LLC1:
.asciz "~: ~ cannot be coerced to type ~"
.section ".text"
.align 4
.global C_coerce
.type C_coerce,#function
.proc 020
C_coerce:
!#PROLOGUE# 0
save %sp, -112, %sp
!#PROLOGUE# 1
ld [%g5-8], %o0
sethi %hi(symbol_tab_data+169), %l0
st %o0, [%g5]
add %g5, 4, %g5
ld [%g5-8], %o0
mov %l0, %l4
st %o0, [%g5]
or %l0, %lo(symbol_tab_data+169), %l0
mov %l0, %o0
add %g5, 4, %g5
call funcall, 0
mov 2, %o1
add %l0, -168, %l0
cmp %g7, %l0
be,a .LL80
ld [%g5-4], %o0
.LL4:
b .LL23
ld [%g5-8], %g7
.LL5:
ld [%g5-4], %o0
.LL80:
and %o0, 7, %o0
cmp %o0, 3
be .LL6
ld [%g5-4], %l1
and %l1, 3, %o0
cmp %o0, 1
bne .LL81
sethi %hi(symbol_tab_data+477), %o0
ldsb [%l1+6], %o0
cmp %o0, 17
bne,a .LL81
sethi %hi(symbol_tab_data+477), %o0
sethi %hi(symbol_tab_data+57), %o0
or %o0, %lo(symbol_tab_data+57), %l2
mov %l2, %o1
call get, 0
mov %l1, %o0
sethi %hi(2147482624), %o1
mov %o0, %o3
or %o1, 959, %o1
cmp %o3, %o1
be .LL10
mov %l1, %l0
st %o3, [%g5]
call allocate_cons, 0
add %g5, 4, %g5
add %g5, -4, %g5
ld [%g5], %o3
mov %o0, %o2
ld [%g5-4], %o1
mov %o3, %o0
st %o1, [%o2+1]
b .LL73
st %o2, [%g5]
.LL10:
add %l2, -28, %o0
cmp %l1, %o0
be .LL4
add %l2, 84, %o0
cmp %l1, %o0
be .LL13
add %l2, 56, %o0
cmp %l1, %o0
be .LL13
add %l2, 28, %o0
cmp %l1, %o0
bne .LL12
add %l2, 140, %o0
.LL13:
call coerce_char, 0
ld [%g5-8], %o0
mov %o0, %o1
sethi %hi(symbol_tab_data+1), %o0
or %o0, %lo(symbol_tab_data+1), %o0
cmp %o1, %o0
bne,a .LL23
mov %o1, %g7
ld [%g5-8], %o0
sethi %hi(object_tab), %o1
st %o0, [%g5]
ld [%o1+%lo(object_tab)], %o2
add %g5, 4, %g5
st %o2, [%g5]
b .LL15
add %g5, 4, %g5
.LL12:
cmp %l1, %o0
be .LL17
add %l2, 168, %o0
cmp %l1, %o0
be .LL17
add %l2, 196, %o0
cmp %l1, %o0
be .LL17
add %l2, 224, %o0
cmp %l1, %o0
be .LL17
add %l2, 252, %o0
cmp %l1, %o0
bne .LL16
add %l2, 280, %o0
.LL17:
sethi %hi(subr_tab_data+2), %o1
ld [%g5-8], %o0
or %o1, %lo(subr_tab_data+2), %g4
call coerce_float, 0
mov %l1, %o1
b .LL23
mov %o0, %g7
.LL16:
cmp %l1, %o0
bne .LL18
add %l2, 336, %o0
ld [%g5-8], %o0
and %o0, 39, %o0
cmp %o0, 7
be .LL4
ld [%g5-8], %o1
and %o1, 3, %o0
cmp %o0, 1
bne,a .LL82
ld [%g5-8], %o0
ldub [%o1+6], %o0
add %o0, -11, %o0
and %o0, 0xff, %o0
cmp %o0, 5
bleu,a .LL23
ld [%g5-8], %g7
ld [%g5-8], %o0
.LL82:
b .LL74
add %l2, 308, %o1
.LL18:
cmp %l1, %o0
bne .LL21
add %l2, 448, %o0
ld [%g5-8], %l0
call funnamep, 0
mov %l0, %o0
cmp %o0, 0
be .LL22
mov %l0, %o0
call sym_function, 0
add %l2, -56, %o1
mov %o0, %g7
and %g7, 3, %o0
cmp %o0, 2
be .LL23
cmp %o0, 1
ldub [%g7+6], %o1
bne .LL24
mov %o0, %o2
ldsb [%g7+6], %o0
cmp %o0, -3
be,a .LL83
mov 1, %g6
.LL24:
cmp %o2, 1
bne .LL84
add %l2, 420, %o0
cmp %o1, 32
be,a .LL83
mov 1, %g6
.LL84:
call fehler_undef_function, 0
mov %l0, %o1
.LL23:
mov 1, %g6
.LL83:
b .LL2
add %g5, -8, %g5
.LL22:
and %l0, 7, %o0
cmp %o0, 3
bne,a .LL85
st %l0, [%g5]
ld [%l0+1], %o1
add %l2, 364, %o0
cmp %o1, %o0
be,a .LL26
add %l2, -56, %o0
st %l0, [%g5]
.LL85:
sethi %hi(object_tab+4), %o0
b .LL75
ld [%o0+%lo(object_tab+4)], %o1
.LL26:
st %o0, [%g5]
add %g5, 4, %g5
st %o0, [%g5]
add %g5, 4, %g5
st %o0, [%g5]
add %g5, 4, %g5
st %o0, [%g5]
sethi %hi(object_tab+8), %o1
ld [%o1+%lo(object_tab+8)], %o0
add %g5, 4, %g5
st %o0, [%g5]
add %g5, 4, %g5
ld [%l0-3], %o0
add %g5, -20, %o3
add %l2, 392, %o1
call get_closure, 0
mov 0, %o2
mov %o0, %g7
mov 1, %g6
b .LL2
add %g5, -28, %g5
.LL21:
cmp %l1, %o0
be .LL29
add %l2, 476, %o0
cmp %l1, %o0
be .LL29
add %l2, 504, %o0
cmp %l1, %o0
be .LL29
add %l2, 532, %o0
cmp %l1, %o0
be .LL29
add %l2, 616, %o0
cmp %l1, %o0
be .LL29
add %l2, 644, %o0
cmp %l1, %o0
be .LL29
add %l2, 672, %o0
cmp %l1, %o0
be .LL29
add %l2, 700, %o0
cmp %l1, %o0
be .LL29
add %l2, 560, %o0
cmp %l1, %o0
be .LL29
add %l2, 588, %o0
cmp %l1, %o0
bne,a .LL28
ld [%g5-8], %o0
.LL29:
sethi %hi(symbol_tab_data+505), %o0
or %o0, %lo(symbol_tab_data+505), %o2
cmp %l1, %o2
be .LL31
add %o2, 56, %o0
cmp %l1, %o0
bne .LL30
add %o2, 28, %o0
.LL31:
ld [%g5-8], %o0
and %o0, 3, %o0
cmp %o0, 1
bne .LL32
ld [%g5-8], %o1
ldub [%o1+6], %o0
add %o0, -6, %o0
and %o0, 0xff, %o0
cmp %o0, 3
bleu,a .LL23
ld [%g5-8], %g7
.LL32:
and %o1, 3, %o0
cmp %o0, 1
bne,a .LL86
st %l0, [%g5]
ldsb [%o1+6], %o0
cmp %o0, 3
be .LL4
cmp %o0, 2
bne,a .LL86
st %l0, [%g5]
ld [%o1+3], %o0
andcc %o0, 1792, %g0
bne,a .LL86
st %l0, [%g5]
b .LL23
ld [%g5-8], %g7
.LL30:
cmp %l1, %o0
bne,a .LL86
st %l0, [%g5]
ld [%g5-8], %o0
and %o0, 3, %o0
cmp %o0, 1
bne .LL38
ld [%g5-8], %o1
ldub [%o1+6], %o0
add %o0, -6, %o0
and %o0, 0xff, %o0
cmp %o0, 3
bgu .LL87
and %o1, 3, %o0
b .LL36
add %o2, 196, %l0
.LL38:
and %o1, 3, %o0
.LL87:
cmp %o0, 1
bne,a .LL86
st %l0, [%g5]
ldsb [%o1+6], %o0
cmp %o0, 3
be .LL41
cmp %o0, 2
bne,a .LL86
st %l0, [%g5]
ld [%o1+3], %o0
andcc %o0, 1792, %g0
bne,a .LL86
st %l0, [%g5]
.LL41:
sethi %hi(symbol_tab_data+645), %o0
or %o0, %lo(symbol_tab_data+645), %l0
.LL36:
st %l0, [%g5]
.LL86:
add %g5, 4, %g5
ld [%g5-12], %o0
call coerce_sequence, 0
mov %l0, %o1
mov %g7, %o1
st %o1, [%g5]
add %g5, 4, %g5
ld [%g5-8], %o0
or %l4, %lo(symbol_tab_data+169), %l0
st %o0, [%g5]
add %g5, 4, %g5
st %o1, [%g5-12]
mov %l0, %o0
call funcall, 0
mov 2, %o1
add %l0, -168, %l0
cmp %g7, %l0
bne,a .LL88
ld [%g5-4], %g7
sethi %hi(subr_tab_data+26), %o0
or %o0, %lo(subr_tab_data+26), %o0
b .LL76
mov 1, %o1
.LL28:
call coerce_sequence, 0
mov %l1, %o1
b .LL2
add %g5, -8, %g5
.LL6:
mov %l1, %l3
ld [%l3+1], %l0
and %l0, 3, %o0
cmp %o0, 1
bne .LL81
sethi %hi(symbol_tab_data+477), %o0
ldsb [%l0+6], %o0
cmp %o0, 17
bne .LL81
sethi %hi(symbol_tab_data+477), %o0
sethi %hi(symbol_tab_data+785), %o0
or %o0, %lo(symbol_tab_data+785), %l2
cmp %l0, %l2
bne .LL47
add %l2, -728, %o1
ld [%l3-3], %o0
and %o0, 7, %o0
cmp %o0, 3
bne,a .LL23
ld [%g5-8], %g7
ld [%g5-8], %o1
sethi %hi(subr_tab_data+2), %o0
st %o1, [%g5]
ld [%l3-3], %o2
add %g5, 4, %g5
ld [%o2+1], %o1
or %o0, %lo(subr_tab_data+2), %o0
st %o1, [%g5]
add %g5, 4, %g5
call funcall, 0
mov 2, %o1
.LL49:
st %g7, [%g5]
.LL79:
add %g5, 4, %g5
st %g7, [%g5]
add %g5, 4, %g5
ld [%g5-12], %o0
or %l4, %lo(symbol_tab_data+169), %l0
st %o0, [%g5]
mov %l0, %o0
add %g5, 4, %g5
call funcall, 0
mov 2, %o1
add %l0, -168, %l0
cmp %g7, %l0
bne,a .LL50
ld [%g5-4], %g7
ld [%g5-8], %o0
st %o0, [%g5]
b .LL15
add %g5, 4, %g5
.LL50:
.LL88:
mov 1, %g6
b .LL2
add %g5, -12, %g5
.LL47:
call get, 0
mov %l0, %o0
mov %o0, %o1
sethi %hi(2147482624), %o0
or %o0, 959, %o0
cmp %o1, %o0
be .LL52
mov %o1, %o0
st %l3, [%g5]
.LL73:
add %g5, 4, %g5
call funcall, 0
mov 1, %o1
b .LL5
st %g7, [%g5-4]
.LL52:
add %l2, -588, %o0
cmp %l0, %o0
be .LL54
add %l2, -560, %o0
cmp %l0, %o0
be .LL54
add %l2, -532, %o0
cmp %l0, %o0
be .LL54
add %l2, -504, %o0
cmp %l0, %o0
be .LL54
add %l2, -476, %o0
cmp %l0, %o0
bne .LL53
add %l2, -448, %o0
.LL54:
sethi %hi(subr_tab_data+2), %o1
or %o1, %lo(subr_tab_data+2), %g4
ld [%g5-8], %o0
call coerce_float, 0
mov %l1, %o1
b .LL49
mov %o0, %g7
.LL53:
cmp %l0, %o0
bne .LL55
add %l2, -280, %o0
ld [%g5-8], %o0
and %o0, 39, %o0
cmp %o0, 7
be .LL56
ld [%g5-8], %o1
and %o1, 3, %o0
cmp %o0, 1
bne,a .LL89
ld [%g5-8], %o0
ldub [%o1+6], %o0
add %o0, -11, %o0
and %o0, 0xff, %o0
cmp %o0, 5
bleu,a .LL90
ld [%l1-3], %o1
ld [%g5-8], %o0
.LL89:
add %l2, -420, %o1
.LL74:
st %o0, [%g5]
.LL75:
add %g5, 4, %g5
st %o1, [%g5]
b .LL15
add %g5, 4, %g5
.LL56:
ld [%l1-3], %o1
.LL90:
and %o1, 7, %o0
cmp %o0, 3
bne,a .LL81
sethi %hi(symbol_tab_data+477), %o0
mov %o1, %l3
ld [%l3-3], %o2
ld [%l3+1], %o1
and %o2, 7, %o0
cmp %o0, 3
bne .LL59
mov %o1, %o0
ld [%o2+1], %o0
.LL59:
st %o1, [%g5]
add %g5, 4, %g5
st %o0, [%g5]
add %g5, 4, %g5
ld [%g5-16], %o0
sethi %hi(subr_tab_data+50), %l0
or %l0, %lo(subr_tab_data+50), %l0
st %o0, [%g5]
add %g5, 4, %g5
mov %l0, %o0
call funcall, 0
mov 1, %o1
st %g7, [%g5]
add %g5, 4, %g5
ld [%g5-12], %o0
add %l0, -48, %l1
st %o0, [%g5]
add %g5, 4, %g5
mov %l1, %o0
call funcall, 0
mov 2, %o1
ld [%g5-16], %o0
st %g7, [%g5-8]
st %o0, [%g5]
add %g5, 4, %g5
mov 1, %o1
call funcall, 0
add %l0, 24, %o0
st %g7, [%g5]
add %g5, 4, %g5
ld [%g5-8], %o1
mov %l1, %o0
st %o1, [%g5]
add %g5, 4, %g5
call funcall, 0
mov 2, %o1
st %g7, [%g5-4]
add %l0, 48, %o0
mov 2, %o1
.LL76:
call funcall, 0
nop
b .LL2
add %g5, -8, %g5
.LL55:
cmp %l0, %o0
be .LL62
add %l2, -252, %o0
cmp %l0, %o0
be .LL62
add %l2, -224, %o0
cmp %l0, %o0
be .LL62
add %l2, -196, %o0
cmp %l0, %o0
be .LL62
add %l2, -112, %o0
cmp %l0, %o0
be .LL62
add %l2, -84, %o0
cmp %l0, %o0
be .LL62
add %l2, -56, %o0
cmp %l0, %o0
be .LL62
add %l2, -28, %o0
cmp %l0, %o0
be .LL62
add %l2, -168, %o0
cmp %l0, %o0
be .LL62
add %l2, -140, %o0
cmp %l0, %o0
bne .LL81
sethi %hi(symbol_tab_data+477), %o0
.LL62:
sethi %hi(symbol_tab_data+505), %o0
or %o0, %lo(symbol_tab_data+505), %o1
cmp %l0, %o1
be .LL64
add %o1, 28, %o0
cmp %l0, %o0
be .LL64
add %o1, 56, %o0
cmp %l0, %o0
bne,a .LL91
st %l0, [%g5]
.LL64:
ld [%l1-3], %o2
sethi %hi(symbol_tab_data+1), %o0
or %o0, %lo(symbol_tab_data+1), %o3
cmp %o2, %o3
be .LL66
and %o2, 7, %o0
cmp %o0, 3
bne .LL9
sethi %hi(symbol_tab_data+477), %o0
ld [%o2+1], %o1
add %o3, 812, %o0
cmp %o1, %o0
bne,a .LL91
st %l0, [%g5]
ld [%o2-3], %o2
.LL66:
st %l0, [%g5]
add %g5, 4, %g5
st %o2, [%g5]
add %g5, 4, %g5
ld [%g5-16], %o0
and %o0, 3, %o0
cmp %o0, 1
bne .LL92
sethi %hi(symbol_tab_data+29), %o0
ld [%g5-16], %o1
ldub [%o1+6], %o0
add %o0, -1, %o0
and %o0, 0xff, %o0
cmp %o0, 9
bgu .LL69
sethi %hi(symbol_tab_data+29), %o0
call array_element_type, 0
mov %o1, %o0
b .LL78
st %o0, [%g5]
.LL69:
.LL92:
or %o0, %lo(symbol_tab_data+29), %o0
st %o0, [%g5]
.LL78:
call allocate_cons, 0
add %g5, 4, %g5
add %g5, -4, %g5
ld [%g5], %o1
add %g5, -4, %g5
st %o1, [%o0+1]
ld [%g5], %o1
st %o1, [%o0-3]
st %o0, [%g5]
call allocate_cons, 0
add %g5, 4, %g5
add %g5, -4, %g5
ld [%g5], %o1
mov %o0, %l3
st %o1, [%o0-3]
add %g5, -4, %g5
ld [%g5], %l0
st %l0, [%o0+1]
st %l0, [%g5]
.LL91:
add %g5, 4, %g5
ld [%g5-12], %o0
call coerce_sequence, 0
mov %l3, %o1
mov %g7, %o1
st %o1, [%g5]
add %g5, 4, %g5
ld [%g5-8], %o0
or %l4, %lo(symbol_tab_data+169), %l0
st %o0, [%g5]
add %g5, 4, %g5
st %o1, [%g5-12]
mov %l0, %o0
call funcall, 0
mov 2, %o1
add %l0, -168, %l0
cmp %g7, %l0
be .LL71
sethi %hi(subr_tab_data+26), %o0
add %g5, -4, %g5
b .LL49
ld [%g5], %g7
.LL71:
or %o0, %lo(subr_tab_data+26), %o0
call funcall, 0
mov 1, %o1
b .LL79
st %g7, [%g5]
.LL9:
.LL81:
or %o0, %lo(symbol_tab_data+477), %o0
st %o0, [%g5]
sethi %hi(.LLC0), %o0
or %o0, %lo(.LLC0), %o0
call clgettext, 0
add %g5, 4, %g5
mov %o0, %o1
call fehler, 0
mov 2, %o0
.LL15:
ld [%g5-12], %o1
sethi %hi(symbol_tab_data+477), %o0
st %o1, [%g5]
add %g5, 4, %g5
ld [%g5-20], %o1
or %o0, %lo(symbol_tab_data+477), %o0
st %o1, [%g5]
add %g5, 4, %g5
st %o0, [%g5]
sethi %hi(.LLC1), %o0
or %o0, %lo(.LLC1), %o0
call clgettext, 0
add %g5, 4, %g5
mov %o0, %o1
call fehler, 0
mov 14, %o0
.LL2:
ret
restore
.LLfe1:
.size C_coerce,.LLfe1-C_coerce
.ident "GCC: (GNU) gcc-2.95 19990623 (prerelease)"
=============================== bug.s.ok ===================================
.file "bug.c"
gcc2_compiled.:
.section ".rodata"
.align 8
.LLC0:
.asciz "~: bad type specification ~"
.align 8
.LLC1:
.asciz "~: ~ cannot be coerced to type ~"
.section ".text"
.align 4
.global C_coerce
.type C_coerce,#function
.proc 020
C_coerce:
!#PROLOGUE# 0
save %sp, -112, %sp
!#PROLOGUE# 1
ld [%g5-8], %o0
sethi %hi(symbol_tab_data+169), %l0
st %o0, [%g5]
add %g5, 4, %g5
ld [%g5-8], %o0
or %l0, %lo(symbol_tab_data+169), %l0
st %o0, [%g5]
mov %l0, %o0
add %g5, 4, %g5
call funcall, 0
mov 2, %o1
add %l0, -168, %l0
cmp %g7, %l0
be,a .LL80
ld [%g5-4], %o0
.LL4:
b .LL23
ld [%g5-8], %g7
.LL5:
ld [%g5-4], %o0
.LL80:
and %o0, 7, %o0
cmp %o0, 3
be,a .LL6
ld [%g5-4], %l2
ld [%g5-4], %o0
and %o0, 3, %o0
cmp %o0, 1
bne .LL81
sethi %hi(symbol_tab_data+477), %o0
ld [%g5-4], %o0
ldsb [%o0+6], %o1
cmp %o1, 17
bne,a .LL81
sethi %hi(symbol_tab_data+477), %o0
mov %o0, %l0
sethi %hi(symbol_tab_data+57), %o0
or %o0, %lo(symbol_tab_data+57), %l1
mov %l1, %o1
call get, 0
mov %l0, %o0
sethi %hi(2147482624), %o1
mov %o0, %o3
or %o1, 959, %o1
cmp %o3, %o1
be .LL10
add %l1, -28, %o0
st %o3, [%g5]
call allocate_cons, 0
add %g5, 4, %g5
add %g5, -4, %g5
ld [%g5], %o3
mov %o0, %o2
ld [%g5-4], %o1
mov %o3, %o0
st %o1, [%o2+1]
b .LL73
st %o2, [%g5]
.LL10:
cmp %l0, %o0
be .LL4
add %l1, 84, %o0
cmp %l0, %o0
be .LL13
add %l1, 56, %o0
cmp %l0, %o0
be .LL13
add %l1, 28, %o0
cmp %l0, %o0
bne .LL12
add %l1, 140, %o0
.LL13:
call coerce_char, 0
ld [%g5-8], %o0
mov %o0, %o1
sethi %hi(symbol_tab_data+1), %o0
or %o0, %lo(symbol_tab_data+1), %o0
cmp %o1, %o0
bne,a .LL23
mov %o1, %g7
ld [%g5-8], %o0
sethi %hi(object_tab), %o1
st %o0, [%g5]
ld [%o1+%lo(object_tab)], %o2
add %g5, 4, %g5
st %o2, [%g5]
b .LL15
add %g5, 4, %g5
.LL12:
cmp %l0, %o0
be .LL17
add %l1, 168, %o0
cmp %l0, %o0
be .LL17
add %l1, 196, %o0
cmp %l0, %o0
be .LL17
add %l1, 224, %o0
cmp %l0, %o0
be .LL17
add %l1, 252, %o0
cmp %l0, %o0
bne .LL16
add %l1, 280, %o0
.LL17:
sethi %hi(subr_tab_data+2), %o1
ld [%g5-8], %o0
or %o1, %lo(subr_tab_data+2), %g4
call coerce_float, 0
mov %l0, %o1
b .LL23
mov %o0, %g7
.LL16:
cmp %l0, %o0
bne .LL18
add %l1, 336, %o0
ld [%g5-8], %o0
and %o0, 39, %o0
cmp %o0, 7
be,a .LL23
ld [%g5-8], %g7
ld [%g5-8], %o0
and %o0, 3, %o0
cmp %o0, 1
bne,a .LL82
ld [%g5-8], %o0
ld [%g5-8], %o1
ldub [%o1+6], %o0
add %o0, -11, %o0
and %o0, 0xff, %o0
cmp %o0, 5
bleu,a .LL23
ld [%g5-8], %g7
ld [%g5-8], %o0
.LL82:
b .LL74
add %l1, 308, %o1
.LL18:
cmp %l0, %o0
bne .LL21
add %l1, 448, %o0
ld [%g5-8], %l0
call funnamep, 0
mov %l0, %o0
cmp %o0, 0
be .LL22
mov %l0, %o0
call sym_function, 0
add %l1, -56, %o1
mov %o0, %g7
and %g7, 3, %o0
cmp %o0, 2
be .LL23
cmp %o0, 1
bne .LL84
add %l1, 420, %o0
ldsb [%g7+6], %o0
cmp %o0, -3
be .LL23
and %g7, 3, %o0
cmp %o0, 1
bne .LL84
add %l1, 420, %o0
ldsb [%g7+6], %o0
cmp %o0, 32
be .LL23
add %l1, 420, %o0
.LL84:
call fehler_undef_function, 0
mov %l0, %o1
.LL23:
mov 1, %g6
b .LL2
add %g5, -8, %g5
.LL22:
and %l0, 7, %o0
cmp %o0, 3
bne,a .LL85
st %l0, [%g5]
ld [%l0+1], %o1
add %l1, 364, %o0
cmp %o1, %o0
be,a .LL26
add %l1, -56, %o0
st %l0, [%g5]
.LL85:
sethi %hi(object_tab+4), %o0
b .LL75
ld [%o0+%lo(object_tab+4)], %o1
.LL26:
st %o0, [%g5]
add %g5, 4, %g5
st %o0, [%g5]
add %g5, 4, %g5
st %o0, [%g5]
add %g5, 4, %g5
st %o0, [%g5]
sethi %hi(object_tab+8), %o1
ld [%o1+%lo(object_tab+8)], %o0
add %g5, 4, %g5
st %o0, [%g5]
add %g5, 4, %g5
ld [%l0-3], %o0
add %g5, -20, %o3
add %l1, 392, %o1
call get_closure, 0
mov 0, %o2
mov %o0, %g7
mov 1, %g6
b .LL2
add %g5, -28, %g5
.LL21:
cmp %l0, %o0
be .LL29
add %l1, 476, %o0
cmp %l0, %o0
be .LL29
add %l1, 504, %o0
cmp %l0, %o0
be .LL29
add %l1, 532, %o0
cmp %l0, %o0
be .LL29
add %l1, 616, %o0
cmp %l0, %o0
be .LL29
add %l1, 644, %o0
cmp %l0, %o0
be .LL29
add %l1, 672, %o0
cmp %l0, %o0
be .LL29
add %l1, 700, %o0
cmp %l0, %o0
be .LL29
add %l1, 560, %o0
cmp %l0, %o0
be .LL29
add %l1, 588, %o0
cmp %l0, %o0
bne,a .LL28
ld [%g5-8], %o0
.LL29:
sethi %hi(symbol_tab_data+505), %o0
or %o0, %lo(symbol_tab_data+505), %o2
cmp %l0, %o2
be .LL31
add %o2, 56, %o0
cmp %l0, %o0
bne .LL30
add %o2, 28, %o0
.LL31:
ld [%g5-8], %o0
and %o0, 3, %o0
cmp %o0, 1
bne,a .LL86
ld [%g5-8], %o0
ld [%g5-8], %o1
ldub [%o1+6], %o0
add %o0, -6, %o0
and %o0, 0xff, %o0
cmp %o0, 3
bleu,a .LL23
ld [%g5-8], %g7
ld [%g5-8], %o0
.LL86:
and %o0, 3, %o0
cmp %o0, 1
bne,a .LL87
st %l0, [%g5]
ld [%g5-8], %o0
ldsb [%o0+6], %o1
cmp %o1, 3
be .LL4
cmp %o1, 2
bne,a .LL87
st %l0, [%g5]
ld [%o0+3], %o1
andcc %o1, 1792, %g0
bne,a .LL87
st %l0, [%g5]
b .LL23
ld [%g5-8], %g7
.LL30:
cmp %l0, %o0
bne,a .LL87
st %l0, [%g5]
ld [%g5-8], %o0
and %o0, 3, %o0
cmp %o0, 1
bne,a .LL88
ld [%g5-8], %o0
ld [%g5-8], %o1
ldub [%o1+6], %o0
add %o0, -6, %o0
and %o0, 0xff, %o0
cmp %o0, 3
bgu,a .LL38
ld [%g5-8], %o0
b .LL36
add %o2, 196, %l0
.LL38:
.LL88:
and %o0, 3, %o0
cmp %o0, 1
bne,a .LL87
st %l0, [%g5]
ld [%g5-8], %o0
ldsb [%o0+6], %o1
cmp %o1, 3
be .LL41
cmp %o1, 2
bne,a .LL87
st %l0, [%g5]
ld [%o0+3], %o1
andcc %o1, 1792, %g0
bne,a .LL87
st %l0, [%g5]
.LL41:
sethi %hi(symbol_tab_data+645), %o0
or %o0, %lo(symbol_tab_data+645), %l0
.LL36:
st %l0, [%g5]
.LL87:
add %g5, 4, %g5
ld [%g5-12], %o0
call coerce_sequence, 0
mov %l0, %o1
mov %g7, %o1
st %o1, [%g5]
add %g5, 4, %g5
ld [%g5-8], %o0
sethi %hi(symbol_tab_data+169), %l0
st %o0, [%g5]
add %g5, 4, %g5
or %l0, %lo(symbol_tab_data+169), %l0
st %o1, [%g5-12]
mov %l0, %o0
call funcall, 0
mov 2, %o1
add %l0, -168, %l0
cmp %g7, %l0
bne,a .LL89
ld [%g5-4], %g7
sethi %hi(subr_tab_data+26), %o0
or %o0, %lo(subr_tab_data+26), %o0
b .LL76
mov 1, %o1
.LL28:
call coerce_sequence, 0
mov %l0, %o1
b .LL2
add %g5, -8, %g5
.LL6:
ld [%l2+1], %l0
and %l0, 3, %o0
cmp %o0, 1
bne .LL81
sethi %hi(symbol_tab_data+477), %o0
ldsb [%l0+6], %o0
cmp %o0, 17
bne .LL81
sethi %hi(symbol_tab_data+477), %o0
sethi %hi(symbol_tab_data+785), %o0
or %o0, %lo(symbol_tab_data+785), %l1
cmp %l0, %l1
bne .LL47
add %l1, -728, %o1
ld [%l2-3], %o0
and %o0, 7, %o0
cmp %o0, 3
bne,a .LL23
ld [%g5-8], %g7
ld [%g5-8], %o1
sethi %hi(subr_tab_data+2), %o0
st %o1, [%g5]
ld [%l2-3], %o2
add %g5, 4, %g5
ld [%o2+1], %o1
or %o0, %lo(subr_tab_data+2), %o0
st %o1, [%g5]
add %g5, 4, %g5
call funcall, 0
mov 2, %o1
.LL49:
st %g7, [%g5]
.LL79:
add %g5, 4, %g5
st %g7, [%g5]
add %g5, 4, %g5
ld [%g5-12], %o0
sethi %hi(symbol_tab_data+169), %l0
or %l0, %lo(symbol_tab_data+169), %l0
st %o0, [%g5]
mov %l0, %o0
add %g5, 4, %g5
call funcall, 0
mov 2, %o1
add %l0, -168, %l0
cmp %g7, %l0
bne,a .LL50
ld [%g5-4], %g7
ld [%g5-8], %o0
st %o0, [%g5]
b .LL15
add %g5, 4, %g5
.LL50:
.LL89:
mov 1, %g6
b .LL2
add %g5, -12, %g5
.LL47:
call get, 0
mov %l0, %o0
mov %o0, %o1
sethi %hi(2147482624), %o0
or %o0, 959, %o0
cmp %o1, %o0
be .LL52
mov %o1, %o0
st %l2, [%g5]
.LL73:
add %g5, 4, %g5
call funcall, 0
mov 1, %o1
b .LL5
st %g7, [%g5-4]
.LL52:
add %l1, -588, %o0
cmp %l0, %o0
be .LL54
add %l1, -560, %o0
cmp %l0, %o0
be .LL54
add %l1, -532, %o0
cmp %l0, %o0
be .LL54
add %l1, -504, %o0
cmp %l0, %o0
be .LL54
add %l1, -476, %o0
cmp %l0, %o0
bne .LL53
add %l1, -448, %o0
.LL54:
sethi %hi(subr_tab_data+2), %o1
or %o1, %lo(subr_tab_data+2), %g4
ld [%g5-8], %o0
call coerce_float, 0
mov %l2, %o1
b .LL49
mov %o0, %g7
.LL53:
cmp %l0, %o0
bne .LL55
add %l1, -280, %o0
ld [%g5-8], %o0
and %o0, 39, %o0
cmp %o0, 7
be,a .LL90
ld [%l2-3], %o1
ld [%g5-8], %o0
and %o0, 3, %o0
cmp %o0, 1
bne,a .LL91
ld [%g5-8], %o0
ld [%g5-8], %o1
ldub [%o1+6], %o0
add %o0, -11, %o0
and %o0, 0xff, %o0
cmp %o0, 5
bleu,a .LL56
ld [%l2-3], %o1
ld [%g5-8], %o0
.LL91:
add %l1, -420, %o1
.LL74:
st %o0, [%g5]
.LL75:
add %g5, 4, %g5
st %o1, [%g5]
b .LL15
add %g5, 4, %g5
.LL56:
.LL90:
and %o1, 7, %o0
cmp %o0, 3
bne,a .LL81
sethi %hi(symbol_tab_data+477), %o0
mov %o1, %l2
ld [%l2-3], %o2
ld [%l2+1], %o1
and %o2, 7, %o0
cmp %o0, 3
bne .LL59
mov %o1, %o0
ld [%o2+1], %o0
.LL59:
st %o1, [%g5]
add %g5, 4, %g5
st %o0, [%g5]
add %g5, 4, %g5
ld [%g5-16], %o0
sethi %hi(subr_tab_data+50), %l0
or %l0, %lo(subr_tab_data+50), %l0
st %o0, [%g5]
add %g5, 4, %g5
mov %l0, %o0
call funcall, 0
mov 1, %o1
st %g7, [%g5]
add %g5, 4, %g5
ld [%g5-12], %o0
add %l0, -48, %l1
st %o0, [%g5]
add %g5, 4, %g5
mov %l1, %o0
call funcall, 0
mov 2, %o1
ld [%g5-16], %o0
st %g7, [%g5-8]
st %o0, [%g5]
add %g5, 4, %g5
mov 1, %o1
call funcall, 0
add %l0, 24, %o0
st %g7, [%g5]
add %g5, 4, %g5
ld [%g5-8], %o1
mov %l1, %o0
st %o1, [%g5]
add %g5, 4, %g5
call funcall, 0
mov 2, %o1
st %g7, [%g5-4]
add %l0, 48, %o0
mov 2, %o1
.LL76:
call funcall, 0
nop
b .LL2
add %g5, -8, %g5
.LL55:
cmp %l0, %o0
be .LL62
add %l1, -252, %o0
cmp %l0, %o0
be .LL62
add %l1, -224, %o0
cmp %l0, %o0
be .LL62
add %l1, -196, %o0
cmp %l0, %o0
be .LL62
add %l1, -112, %o0
cmp %l0, %o0
be .LL62
add %l1, -84, %o0
cmp %l0, %o0
be .LL62
add %l1, -56, %o0
cmp %l0, %o0
be .LL62
add %l1, -28, %o0
cmp %l0, %o0
be .LL62
add %l1, -168, %o0
cmp %l0, %o0
be .LL62
add %l1, -140, %o0
cmp %l0, %o0
bne .LL81
sethi %hi(symbol_tab_data+477), %o0
.LL62:
sethi %hi(symbol_tab_data+505), %o0
or %o0, %lo(symbol_tab_data+505), %o1
cmp %l0, %o1
be .LL64
add %o1, 28, %o0
cmp %l0, %o0
be .LL64
add %o1, 56, %o0
cmp %l0, %o0
bne,a .LL92
st %l0, [%g5]
.LL64:
ld [%l2-3], %o2
sethi %hi(symbol_tab_data+1), %o0
or %o0, %lo(symbol_tab_data+1), %o3
cmp %o2, %o3
be .LL66
and %o2, 7, %o0
cmp %o0, 3
bne .LL9
sethi %hi(symbol_tab_data+477), %o0
ld [%o2+1], %o1
add %o3, 812, %o0
cmp %o1, %o0
bne,a .LL92
st %l0, [%g5]
ld [%o2-3], %o2
.LL66:
st %l0, [%g5]
add %g5, 4, %g5
st %o2, [%g5]
add %g5, 4, %g5
ld [%g5-16], %o0
and %o0, 3, %o0
cmp %o0, 1
bne .LL93
sethi %hi(symbol_tab_data+29), %o0
ld [%g5-16], %o1
ldub [%o1+6], %o0
add %o0, -1, %o0
and %o0, 0xff, %o0
cmp %o0, 9
bgu .LL69
sethi %hi(symbol_tab_data+29), %o0
call array_element_type, 0
mov %o1, %o0
b .LL78
st %o0, [%g5]
.LL69:
.LL93:
or %o0, %lo(symbol_tab_data+29), %o0
st %o0, [%g5]
.LL78:
call allocate_cons, 0
add %g5, 4, %g5
add %g5, -4, %g5
ld [%g5], %o1
add %g5, -4, %g5
st %o1, [%o0+1]
ld [%g5], %o1
st %o1, [%o0-3]
st %o0, [%g5]
call allocate_cons, 0
add %g5, 4, %g5
add %g5, -4, %g5
ld [%g5], %o1
mov %o0, %l2
st %o1, [%o0-3]
add %g5, -4, %g5
ld [%g5], %l0
st %l0, [%o0+1]
st %l0, [%g5]
.LL92:
add %g5, 4, %g5
ld [%g5-12], %o0
call coerce_sequence, 0
mov %l2, %o1
mov %g7, %o1
st %o1, [%g5]
add %g5, 4, %g5
ld [%g5-8], %o0
sethi %hi(symbol_tab_data+169), %l0
st %o0, [%g5]
add %g5, 4, %g5
or %l0, %lo(symbol_tab_data+169), %l0
st %o1, [%g5-12]
mov %l0, %o0
call funcall, 0
mov 2, %o1
add %l0, -168, %l0
cmp %g7, %l0
be .LL71
sethi %hi(subr_tab_data+26), %o0
add %g5, -4, %g5
b .LL49
ld [%g5], %g7
.LL71:
or %o0, %lo(subr_tab_data+26), %o0
call funcall, 0
mov 1, %o1
b .LL79
st %g7, [%g5]
.LL9:
.LL81:
or %o0, %lo(symbol_tab_data+477), %o0
st %o0, [%g5]
sethi %hi(.LLC0), %o0
or %o0, %lo(.LLC0), %o0
call clgettext, 0
add %g5, 4, %g5
mov %o0, %o1
call fehler, 0
mov 2, %o0
.LL15:
ld [%g5-12], %o1
sethi %hi(symbol_tab_data+477), %o0
st %o1, [%g5]
add %g5, 4, %g5
ld [%g5-20], %o1
or %o0, %lo(symbol_tab_data+477), %o0
st %o1, [%g5]
add %g5, 4, %g5
st %o0, [%g5]
sethi %hi(.LLC1), %o0
or %o0, %lo(.LLC1), %o0
call clgettext, 0
add %g5, 4, %g5
mov %o0, %o1
call fehler, 0
mov 14, %o0
.LL2:
ret
restore
.LLfe1:
.size C_coerce,.LLfe1-C_coerce
.ident "GCC: (GNU) gcc-2.95 19990623 (prerelease)"
============================================================================
More information about the Gcc-bugs
mailing list