frank@morgan.com (Frank Wortner) (09/20/88)
I had a problem compiling GCC 1.28 on a Sun 4 (SPARC CPU) running SunOS 4.0. I was using Sun's C compiler to bootstrap compile GCC. I followed all the instructions in the INSTALL file regarding which links to make, etc. When I ran the make, here is the result: cc -g -sun4 -c expr.c "expr.c", line 1420: nonunique name demands struct/union or struct/union pointer "expr.c", line 1422: nonunique name demands struct/union or struct/union pointer "expr.c", line 1465: nonunique name demands struct/union or struct/union pointer "expr.c", line 1468: nonunique name demands struct/union or struct/union pointer *** Error code 1 All the lines are in the function emit_library call. I've enclosed a copy of the function at the end of the message. I've marked the lines in question with their line numbers followed by >>>. This error did not occur when I set up and compiled GCC on a Sun 3 (68020 CPU) under SunOS 4.0. There the compiler source compiled with no problems, producing a working GCC which compiled itself correctly. I hope that this has been helpful. If not, please tell me if I can do anything else for you. Frank frank@morgan.com uunet!mstan!frank ---------------------Source Code Follows--------------------------------------- void emit_library_call (va_alist) va_dcl { register va_list p; register int args_size = 0; register int argnum; enum machine_mode outmode; int nargs; rtx fun; rtx orgfun; int inc; int count; rtx *regvec; rtx argblock = 0; CUMULATIVE_ARGS args_so_far; struct arg { rtx value; enum machine_mode mode; }; struct arg *argvec; int old_args_size = current_args_size; va_start (p); orgfun = fun = va_arg (p, rtx); outmode = va_arg (p, enum machine_mode); nargs = va_arg (p, int); regvec = (rtx *) alloca (nargs * sizeof (rtx)); /* Copy all the libcall-arguments out of the varargs data and into a vector ARGVEC. */ argvec = (struct arg *) alloca (nargs * sizeof (struct arg)); for (count = 0; count < nargs; count++) { argvec[count].value = va_arg (p, rtx); argvec[count].mode = va_arg (p, enum machine_mode); } va_end (p); /* If we have no actual push instructions, make space for all the args right now. */ #ifndef PUSH_ROUNDING INIT_CUMULATIVE_ARGS (args_so_far, (tree)0); for (count = 0; count < nargs; count++) { register enum machine_mode mode = argvec[count].mode; register rtx reg; register int partial; 1420>>> reg = FUNCTION_ARG (args_so_far, mode, 0, 1); #ifdef FUNCTION_ARG_PARTIAL_NREGS 1422>>> partial = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, 0, 1); #else partial = 0; #endif if (reg == 0 || partial != 0) args_size += GET_MODE_SIZE (mode); if (partial != 0) args_size -= partial * GET_MODE_SIZE (SImode); FUNCTION_ARG_ADVANCE (args_so_far, mode, 0, 1); } if (args_size != 0) argblock = push_block (round_push (gen_rtx (CONST_INT, VOIDmode, args_size))); #endif INIT_CUMULATIVE_ARGS (args_so_far, (tree)0); #ifdef PUSH_ARGS_REVERSED inc = -1; argnum = nargs - 1; #else inc = 1; argnum = 0; #endif args_size = 0; for (count = 0; count < nargs; count++, argnum += inc) { register enum machine_mode mode = argvec[argnum].mode; register rtx val = argvec[argnum].value; rtx reg; int partial; int arg_size; /* Convert the arg value to the mode the library wants. */ /* ??? It is wrong to do it here; must do it earlier where we know the signedness of the arg. */ if (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode) { val = gen_reg_rtx (mode); convert_move (val, argvec[argnum].value, 0); } 1465>>> reg = FUNCTION_ARG (args_so_far, mode, 0, 1); regvec[argnum] = reg; #ifdef FUNCTION_ARG_PARTIAL_NREGS 1468>>> partial = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, 0, 1); #else partial = 0; #endif if (reg != 0 && partial == 0) emit_move_insn (reg, val); else emit_push_insn (val, mode, 0, 0, partial, reg, 0, argblock, gen_rtx (CONST_INT, VOIDmode, args_size)); /* Compute size of stack space used by this argument. */ if (reg == 0 || partial != 0) arg_size = GET_MODE_SIZE (mode); else arg_size = 0; if (partial != 0) arg_size -= ((partial * UNITS_PER_WORD) / (PARM_BOUNDARY / BITS_PER_UNIT) * (PARM_BOUNDARY / BITS_PER_UNIT)); args_size += arg_size; NO_DEFER_POP; FUNCTION_ARG_ADVANCE (args_so_far, mode, 0, 1); } emit_queue (); fun = prepare_call_address (fun, 0); /* Any regs containing parms remain in use through the call. ??? This is not quite correct, since it doesn't indicate that they are in use immediately before the call insn. Currently that doesn't matter since explicitly-used regs won't be used for reloading. But if the reloader becomes smarter, this will have to change somehow. */ for (count = 0; count < nargs; count++) if (regvec[count] != 0) emit_insn (gen_rtx (USE, VOIDmode, regvec[count])); #ifdef STACK_BOUNDARY args_size = (args_size + STACK_BYTES - 1) / STACK_BYTES * STACK_BYTES; #endif /* Don't allow popping to be deferred, since then cse'ing of library calls could delete a call and leave the pop. */ NO_DEFER_POP; emit_call_1 (fun, get_identifier (XSTR (orgfun, 0)), args_size, FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1), outmode != VOIDmode ? hard_libcall_value (outmode) : 0, old_args_size + 1); OK_DEFER_POP; }