+2001-08-17 Richard Henderson <rth@redhat.com>
+
+ * defaults.h (UNALIGNED_SHORT_ASM_OP, UNALIGNED_INT_ASM_OP,
+ UNALIGNED_DOUBLE_INT_ASM_OP, ASM_BYTE_OP): Move from ...
+ * dwarf2asm.c: ... here.
+ * dwarfout.c: Remove them.
+
+ * varasm.c (assemble_integer): Add align parameter.
+ (assemble_real, output_constant, output_constructor): Likewise.
+ * output.h: Update decls.
+ * dwarf2asm.c, final.c, varasm.c, config/darwin.c, config/nextstep.c,
+ config/alpha/alpha.c, config/arm/arm.md, config/clipper/clipper.c,
+ config/m88k/m88k.c, config/mcore/mcore.md, config/mips/mips.h,
+ config/mips/mips.md, config/pa/pa.c, config/rs6000/rs6000.c,
+ config/rs6000/rs6000.h, config/s390/s390.h, config/sh/sh.md:
+ Update all callers.
+
+ * final.c (end_final): Abort profile block generation if we
+ havn't layed it out properly.
+ * output.h (assemble_eh_integer): Remove stale decl.
+ * varasm.c (assemble_zeros): Tidy; use assemble_integer.
+ (min_align): New.
+ (assemble_integer): Handle unaligned data.
+ (assemble_real): Abort on unaligned data.
+ (output_constructor): Don't assume ASM_OUTPUT_ALIGN 0 does
+ anything useful.
+ (default_dtor_section_asm_out_destructor): Use assemble_align.
+ (default_named_section_asm_out_constructor): Likewise.
+ (default_ctor_section_asm_out_constructor): Likewise.
+ * config/darwin.c (machopic_asm_out_constructor): Likewise.
+ (machopic_asm_out_destructor): Likewise.
+ * config/nextstep.c (nextstep_asm_out_constructor): Likewise.
+ (nextstep_asm_out_destructor): Likewise.
+ * config/alpha/alpha.c (vms_asm_out_constructor): Likewise.
+ (vms_asm_out_destructor): Likewise.
+
2001-08-17 Richard Henderson <rth@redhat.com>
* config/mips/iris6.h (TARGET_IRIX6): New.
int priority ATTRIBUTE_UNUSED;
{
ctors_section ();
- assemble_integer (symbol, UNITS_PER_WORD, 1);
+ assemble_align (BITS_PER_WORD);
+ assemble_integer (symbol, UNITS_PER_WORD, BITS_PER_WORD, 1);
}
static void
int priority ATTRIBUTE_UNUSED;
{
dtors_section ();
- assemble_integer (symbol, UNITS_PER_WORD, 1);
+ assemble_align (BITS_PER_WORD);
+ assemble_integer (symbol, UNITS_PER_WORD, BITS_PER_WORD, 1);
}
#else
"TARGET_THUMB"
"*
making_const_table = TRUE;
- assemble_integer (operands[0], 1, 1);
+ assemble_integer (operands[0], 1, BITS_PER_WORD, 1);
assemble_zeros (3);
return \"\";
"
"TARGET_THUMB"
"*
making_const_table = TRUE;
- assemble_integer (operands[0], 2, 1);
+ assemble_integer (operands[0], 2, BITS_PER_WORD, 1);
assemble_zeros (2);
return \"\";
"
{
union real_extract u;
memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
- assemble_real (u.d, GET_MODE (operands[0]));
+ assemble_real (u.d, GET_MODE (operands[0]), BITS_PER_WORD);
break;
}
default:
- assemble_integer (operands[0], 4, 1);
+ assemble_integer (operands[0], 4, BITS_PER_WORD, 1);
break;
}
return \"\";
{
union real_extract u;
memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
- assemble_real (u.d, GET_MODE (operands[0]));
+ assemble_real (u.d, GET_MODE (operands[0]), BITS_PER_WORD);
break;
}
default:
- assemble_integer (operands[0], 8, 1);
+ assemble_integer (operands[0], 8, BITS_PER_WORD, 1);
break;
}
return \"\";
int priority ATTRIBUTE_UNUSED;
{
fini_section ();
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
- assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
+ assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
}
)
{
data_section ();
- assemble_align (UNITS_PER_WORD * BITS_PER_UNIT);
+ assemble_align (GET_MODE_ALIGNMENT (Pmode));
assemble_label (lazy_name);
assemble_integer (gen_rtx (SYMBOL_REF, Pmode, sym_name),
- GET_MODE_SIZE (Pmode), 1);
+ GET_MODE_SIZE (Pmode),
+ GET_MODE_ALIGNMENT (Pmode), 1);
}
else
{
assemble_name (asm_out_file, sym_name);
fprintf (asm_out_file, "\n");
- assemble_integer (const0_rtx, GET_MODE_SIZE (Pmode), 1);
+ assemble_integer (const0_rtx, GET_MODE_SIZE (Pmode),
+ GET_MODE_ALIGNMENT (Pmode), 1);
}
}
}
mod_init_section ();
else
constructor_section ();
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_align (POINTER_SIZE);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
if (!flag_pic)
fprintf (asm_out_file, ".reference .constructors_used\n");
mod_term_section ();
else
destructor_section ();
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_align (POINTER_SIZE);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
if (!flag_pic)
fprintf (asm_out_file, ".reference .destructors_used\n");
int i;
fini_section ();
- assemble_integer (symbol, UNITS_PER_WORD, 1);
+ assemble_integer (symbol, UNITS_PER_WORD, BITS_PER_WORD, 1);
for (i = 1; i < 4; i++)
- assemble_integer (constm1_rtx, UNITS_PER_WORD, 1);
+ assemble_integer (constm1_rtx, UNITS_PER_WORD, BITS_PER_WORD, 1);
}
#endif
""
"*
{
- assemble_integer (operands[0], 4, 1);
+ assemble_integer (operands[0], 4, BITS_PER_WORD, 1);
return \"\";
}"
[(set_attr "length" "4")])
else \
{ \
assemble_integer (operand_subword ((VALUE), 0, 0, DImode), \
- UNITS_PER_WORD, 1); \
+ UNITS_PER_WORD, BITS_PER_WORD, 1); \
assemble_integer (operand_subword ((VALUE), 1, 0, DImode), \
- UNITS_PER_WORD, 1); \
+ UNITS_PER_WORD, BITS_PER_WORD, 1); \
} \
} while (0)
"TARGET_MIPS16"
"*
{
- assemble_integer (operands[0], 1, 1);
+ assemble_integer (operands[0], 1, BITS_PER_UNIT, 1);
return \"\";
}"
[(set_attr "type" "unknown")
"TARGET_MIPS16"
"*
{
- assemble_integer (operands[0], 2, 1);
+ assemble_integer (operands[0], 2, BITS_PER_UNIT * 2, 1);
return \"\";
}"
[(set_attr "type" "unknown")
"TARGET_MIPS16"
"*
{
- assemble_integer (operands[0], 4, 1);
+ assemble_integer (operands[0], 4, BITS_PER_UNIT * 4, 1);
return \"\";
}"
[(set_attr "type" "unknown")
"TARGET_MIPS16"
"*
{
- assemble_integer (operands[0], 8, 1);
+ assemble_integer (operands[0], 8, BITS_PER_UNIT * 8, 1);
return \"\";
}"
[(set_attr "type" "unknown")
if (GET_CODE (operands[0]) != CONST_DOUBLE)
abort ();
memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
- assemble_real (u.d, SFmode);
+ assemble_real (u.d, SFmode, GET_MODE_ALIGNMENT (SFmode));
return \"\";
}"
[(set_attr "type" "unknown")
if (GET_CODE (operands[0]) != CONST_DOUBLE)
abort ();
memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
- assemble_real (u.d, DFmode);
+ assemble_real (u.d, DFmode, GET_MODE_ALIGNMENT (DFmode));
return \"\";
}"
[(set_attr "type" "unknown")
int priority ATTRIBUTE_UNUSED;
{
constructor_section ();
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_align (POINTER_SIZE);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
fprintf (asm_out_file, ".reference .constructors_used\n");
}
int priority ATTRIBUTE_UNUSED;
{
destructor_section ();
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_align (POINTER_SIZE);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
fprintf (asm_out_file, ".reference .destructors_used\n");
}
for (i = 0; i < n_deferred_plabels; i++)
{
ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (deferred_plabels[i].internal_label));
- assemble_integer (gen_rtx_SYMBOL_REF (VOIDmode,
- deferred_plabels[i].name), 4, 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, deferred_plabels[i].name),
+ 4, 32, 1);
}
}
fputs (")@fixup\n", asm_out_file);
}
else
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
}
static void
fputs (")@fixup\n", asm_out_file);
}
else
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
}
#endif
if (TARGET_32BIT) \
{ \
assemble_integer (operand_subword ((VALUE), 0, 0, DImode), \
- UNITS_PER_WORD, 1); \
+ UNITS_PER_WORD, BITS_PER_WORD, 1); \
assemble_integer (operand_subword ((VALUE), 1, 0, DImode), \
- UNITS_PER_WORD, 1); \
+ UNITS_PER_WORD, BITS_PER_WORD, 1); \
} \
else \
{ \
/* Mark entries referenced by other entries */ \
for (pool = first_pool; pool; pool = pool->next) \
if (pool->mark) \
- mark_constants (pool->constant); \
+ mark_constants (pool->constant); \
\
s390_asm_output_pool_prologue (FILE, FUNNAME, fndecl, size); \
}
#define ASM_OUTPUT_POOL_EPILOGUE(FILE, FUNNAME, fndecl, size) return;
#define ASM_OUTPUT_SPECIAL_POOL_ENTRY(FILE, EXP, MODE, ALIGN, LABELNO, WIN) \
-{ \
- if ((s390_pool_count == 0) || (s390_pool_count > 0 && LABELNO >= 0)) \
- { \
- fprintf (FILE, ".LC%d:\n", LABELNO); \
- LABELNO = ~LABELNO; \
- } \
- if (s390_pool_count > 0) \
- { \
- fprintf (FILE, ".LC%d_%X:\n", ~LABELNO, s390_pool_count); \
- } \
- \
- /* Output the value of the constant itself. */ \
- switch (GET_MODE_CLASS (pool->mode)) \
- { \
- case MODE_FLOAT: \
- if (GET_CODE (x) != CONST_DOUBLE) \
- abort (); \
- \
- memcpy ((char *) &u, (char *) &CONST_DOUBLE_LOW (x), sizeof u); \
- assemble_real (u.d, pool->mode); \
- break; \
- \
- case MODE_INT: \
- case MODE_PARTIAL_INT: \
- if (flag_pic && (GET_CODE (x) == CONST || \
- GET_CODE (x) == SYMBOL_REF || \
- GET_CODE (x) == LABEL_REF )) \
- { \
- fprintf (FILE, "%s\t",TARGET_64BIT ? ASM_QUAD : ASM_LONG); \
- s390_output_symbolic_const (FILE, x); \
- fputc ('\n', (FILE)); \
- } \
- else \
- assemble_integer (x, GET_MODE_SIZE (pool->mode), 1); \
- break; \
- \
- default: \
- abort (); \
- } \
- goto WIN; \
+{ \
+ if ((s390_pool_count == 0) || (s390_pool_count > 0 && LABELNO >= 0)) \
+ { \
+ fprintf (FILE, ".LC%d:\n", LABELNO); \
+ LABELNO = ~LABELNO; \
+ } \
+ if (s390_pool_count > 0) \
+ { \
+ fprintf (FILE, ".LC%d_%X:\n", ~LABELNO, s390_pool_count); \
+ } \
+ \
+ /* Output the value of the constant itself. */ \
+ switch (GET_MODE_CLASS (MODE)) \
+ { \
+ case MODE_FLOAT: \
+ if (GET_CODE (EXP) != CONST_DOUBLE) \
+ abort (); \
+ \
+ memcpy ((char *) &u, (char *) &CONST_DOUBLE_LOW (EXP), sizeof u); \
+ assemble_real (u.d, MODE, ALIGN); \
+ break; \
+ \
+ case MODE_INT: \
+ case MODE_PARTIAL_INT: \
+ if (flag_pic \
+ && (GET_CODE (EXP) == CONST \
+ || GET_CODE (EXP) == SYMBOL_REF \
+ || GET_CODE (EXP) == LABEL_REF )) \
+ { \
+ fprintf (FILE, "%s\t",TARGET_64BIT ? ASM_QUAD : ASM_LONG); \
+ s390_output_symbolic_const (FILE, EXP); \
+ fputc ('\n', (FILE)); \
+ } \
+ else \
+ assemble_integer (EXP, GET_MODE_SIZE (MODE), ALIGN, 1); \
+ break; \
+ \
+ default: \
+ abort (); \
+ } \
+ goto WIN; \
}
#endif
"*
{
if (operands[1] != const0_rtx)
- assemble_integer (operands[0], 2, 1);
+ assemble_integer (operands[0], 2, BITS_PER_UNIT * 2, 1);
return \"\";
}"
[(set_attr "length" "2")
"*
{
if (operands[1] != const0_rtx)
- assemble_integer (operands[0], 4, 1);
+ assemble_integer (operands[0], 4, BITS_PER_UNIT * 4, 1);
return \"\";
}"
[(set_attr "length" "4")
"*
{
if (operands[1] != const0_rtx)
- assemble_integer (operands[0], 8, 1);
+ assemble_integer (operands[0], 8, BITS_PER_UNIT * 8, 1);
return \"\";
}"
[(set_attr "length" "8")
{
union real_extract u;
memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
- assemble_real (u.d, SFmode);
+ assemble_real (u.d, SFmode, GET_MODE_ALIGNMENT (SFmode));
}
return \"\";
}"
{
union real_extract u;
memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
- assemble_real (u.d, DFmode);
+ assemble_real (u.d, DFmode, GET_MODE_ALIGNMENT (DFmode));
}
return \"\";
}"
#define TARGET_ALLOWS_PROFILING_WITHOUT_FRAME_POINTER true
#endif
+/* GAS and SYSV4 assemblers accept these. */
+#ifdef OBJECT_FORMAT_ELF
+#ifndef UNALIGNED_SHORT_ASM_OP
+#define UNALIGNED_SHORT_ASM_OP "\t.2byte\t"
+#endif
+#ifndef UNALIGNED_INT_ASM_OP
+#define UNALIGNED_INT_ASM_OP "\t.4byte\t"
+#endif
+#ifndef UNALIGNED_DOUBLE_INT_ASM_OP
+#define UNALIGNED_DOUBLE_INT_ASM_OP "\t.8byte\t"
+#endif
+#endif /* OBJECT_FORMAT_ELF */
+
+#ifndef ASM_BYTE_OP
+#define ASM_BYTE_OP "\t.byte\t"
+#endif
+
#endif /* ! GCC_DEFAULTS_H */
#define ASM_COMMENT_START ";#"
#endif
-/* Definitions of defaults for assembler-dependent names of various
- pseudo-ops and section names. These may be overridden in the tm.h
- file (if necessary) for a particular assembler. */
-
-#ifdef OBJECT_FORMAT_ELF
-#ifndef UNALIGNED_SHORT_ASM_OP
-#define UNALIGNED_SHORT_ASM_OP "\t.2byte\t"
-#endif
-#ifndef UNALIGNED_INT_ASM_OP
-#define UNALIGNED_INT_ASM_OP "\t.4byte\t"
-#endif
-#ifndef UNALIGNED_DOUBLE_INT_ASM_OP
-#define UNALIGNED_DOUBLE_INT_ASM_OP "\t.8byte\t"
-#endif
-#endif /* OBJECT_FORMAT_ELF */
-
-#ifndef ASM_BYTE_OP
-#define ASM_BYTE_OP "\t.byte\t"
-#endif
-
/* We don't have unaligned support, let's hope the normal output works for
.debug_frame. But we know it won't work for .debug_info. */
#if !defined(UNALIGNED_INT_ASM_OP) && defined(DWARF2_DEBUGGING_INFO)
#endif
\f
+/* Despite the fact that assemble_integer handles unaligned data,
+ continue emitting things by hand when possible, since that makes
+ the assembler commentary come out prettier. */
#ifdef UNALIGNED_INT_ASM_OP
static const char * unaligned_integer_asm_op PARAMS ((int));
fputs (unaligned_integer_asm_op (size), asm_out_file);
fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);
#else
- assemble_integer (GEN_INT (value), size, 1);
+ assemble_integer (GEN_INT (value), size, BITS_PER_UNIT, 1);
#endif
if (flag_debug_asm && comment)
fputc ('-', asm_out_file);
assemble_name (asm_out_file, lab2);
#else
- assemble_integer (gen_rtx_MINUS (smallest_mode_for_size (size, MODE_INT),
- gen_rtx_SYMBOL_REF (Pmode, lab1),
+ assemble_integer (gen_rtx_MINUS (Pmode, gen_rtx_SYMBOL_REF (Pmode, lab1),
gen_rtx_SYMBOL_REF (Pmode, lab2)),
- size, 1);
+ size, BITS_PER_UNIT, 1);
#endif
if (flag_debug_asm && comment)
fputs (unaligned_integer_asm_op (size), asm_out_file);
assemble_name (asm_out_file, label);
#else
- assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, BITS_PER_UNIT, 1);
#endif
#endif
fputs (unaligned_integer_asm_op (size), asm_out_file);
assemble_name (asm_out_file, label);
#else
- assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, BITS_PER_UNIT, 1);
#endif
if (flag_debug_asm && comment)
fputs (unaligned_integer_asm_op (size), asm_out_file);
output_addr_const (asm_out_file, addr);
#else
- assemble_integer (addr, size, 1);
+ assemble_integer (addr, size, BITS_PER_UNIT, 1);
#endif
if (flag_debug_asm && comment)
sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym);
ASM_OUTPUT_LABEL (asm_out_file, label);
- assemble_integer (sym_ref, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_integer (sym_ref, POINTER_SIZE / BITS_PER_UNIT, BITS_PER_UNIT, 1);
return 0;
}
/* NULL is _always_ represented as a plain zero. */
if (addr == const0_rtx)
- assemble_integer (addr, size, 1);
+ assemble_integer (addr, size, BITS_PER_UNIT, 1);
else
{
restart:
fputs (unaligned_integer_asm_op (size), asm_out_file);
output_addr_const (asm_out_file, addr);
#else
- assemble_integer (addr, size, 1);
+ assemble_integer (addr, size, BITS_PER_UNIT, 1);
#endif
break;
#ifndef VERSION_ASM_OP
#define VERSION_ASM_OP "\t.version\t"
#endif
-#ifndef UNALIGNED_SHORT_ASM_OP
-#define UNALIGNED_SHORT_ASM_OP "\t.2byte\t"
-#endif
-#ifndef UNALIGNED_INT_ASM_OP
-#define UNALIGNED_INT_ASM_OP "\t.4byte\t"
-#endif
-#ifndef ASM_BYTE_OP
-#define ASM_BYTE_OP "\t.byte\t"
-#endif
#ifndef SET_ASM_OP
#define SET_ASM_OP "\t.set\t"
#endif
int long_bytes = LONG_TYPE_SIZE / BITS_PER_UNIT;
int gcov_type_bytes = GCOV_TYPE_SIZE / BITS_PER_UNIT;
int pointer_bytes = POINTER_SIZE / BITS_PER_UNIT;
+ unsigned int align2 = LONG_TYPE_SIZE;
if (profile_block_flag)
size = long_bytes * count_basic_blocks;
rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
* (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
+ /* ??? This _really_ ought to be done with a structure layout
+ and with assemble_constructor. If long_bytes != pointer_bytes
+ we'll be emitting unaligned data at some point. */
+ if (long_bytes != pointer_bytes)
+ abort ();
+
data_section ();
/* Output the main header, of 11 words:
ASM_OUTPUT_ALIGN (asm_out_file, align);
ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 0);
- /* zero word */
- assemble_integer (const0_rtx, long_bytes, 1);
- /* address of filename */
+ /* Zero word. */
+ assemble_integer (const0_rtx, long_bytes, align2, 1);
+
+ /* Address of filename. */
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 1);
- assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes,
+ align2, 1);
- /* address of count table */
+ /* Address of count table. */
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2);
- assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes,
+ align2, 1);
- /* count of the # of basic blocks or # of instrumented arcs */
+ /* Count of the # of basic blocks or # of instrumented arcs. */
if (profile_block_flag)
- assemble_integer (GEN_INT (count_basic_blocks), long_bytes, 1);
- else
- assemble_integer (GEN_INT (count_instrumented_edges), long_bytes, 1);
+ assemble_integer (GEN_INT (profile_block_flag
+ ? count_basic_blocks
+ : count_instrumented_edges),
+ long_bytes, align2, 1);
- /* zero word (link field) */
- assemble_integer (const0_rtx, pointer_bytes, 1);
+ /* Zero word (link field). */
+ assemble_integer (const0_rtx, pointer_bytes, align2, 1);
/* address of basic block start address table */
if (profile_block_flag)
{
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3);
- assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes,
- 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
+ pointer_bytes, align2, 1);
}
else
- assemble_integer (const0_rtx, pointer_bytes, 1);
+ assemble_integer (const0_rtx, pointer_bytes, align2, 1);
- /* byte count for extended structure. */
- assemble_integer (GEN_INT (11 * UNITS_PER_WORD), long_bytes, 1);
+ /* Byte count for extended structure. */
+ assemble_integer (GEN_INT (11 * UNITS_PER_WORD), long_bytes, align2, 1);
- /* address of function name table */
+ /* Address of function name table. */
if (profile_block_flag)
{
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 4);
- assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes,
- 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
+ pointer_bytes, align2, 1);
}
else
- assemble_integer (const0_rtx, pointer_bytes, 1);
+ assemble_integer (const0_rtx, pointer_bytes, align2, 1);
- /* address of line number and filename tables if debugging. */
+ /* Address of line number and filename tables if debugging. */
if (write_symbols != NO_DEBUG && profile_block_flag)
{
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 5);
assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
- pointer_bytes, 1);
+ pointer_bytes, align2, 1);
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 6);
assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
- pointer_bytes, 1);
+ pointer_bytes, align2, 1);
}
else
{
- assemble_integer (const0_rtx, pointer_bytes, 1);
- assemble_integer (const0_rtx, pointer_bytes, 1);
+ assemble_integer (const0_rtx, pointer_bytes, align2, 1);
+ assemble_integer (const0_rtx, pointer_bytes, align2, 1);
}
- /* space for extension ptr (link field) */
- assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
+ /* Space for extension ptr (link field). */
+ assemble_integer (const0_rtx, UNITS_PER_WORD, align2, 1);
- /* Output the file name changing the suffix to .d for Sun tcov
- compatibility. */
+ /* Output the file name changing the suffix to .d for
+ Sun tcov compatibility. */
ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 1);
{
char *cwd = getpwd ();
{
ASM_GENERATE_INTERNAL_LABEL (name, "LPB", i);
assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
- pointer_bytes, 1);
+ pointer_bytes, align2, 1);
}
}
ASM_GENERATE_INTERNAL_LABEL (name, "LPBC",
ptr->func_label_num);
assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
- pointer_bytes, 1);
+ pointer_bytes, align2, 1);
}
else
- assemble_integer (const0_rtx, pointer_bytes, 1);
+ assemble_integer (const0_rtx, pointer_bytes, align2, 1);
}
for (; i < count_basic_blocks; i++)
- assemble_integer (const0_rtx, pointer_bytes, 1);
+ assemble_integer (const0_rtx, pointer_bytes, align2, 1);
}
if (write_symbols != NO_DEBUG && profile_block_flag)
/* Output the table of line numbers. */
ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 5);
for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++)
- assemble_integer (GEN_INT (ptr->line_num), long_bytes, 1);
+ assemble_integer (GEN_INT (ptr->line_num), long_bytes, align2, 1);
for (; i < count_basic_blocks; i++)
- assemble_integer (const0_rtx, long_bytes, 1);
+ assemble_integer (const0_rtx, long_bytes, align2, 1);
/* Output the table of file names. */
ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 6);
ASM_GENERATE_INTERNAL_LABEL (name, "LPBC",
ptr->file_label_num);
assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
- pointer_bytes, 1);
+ pointer_bytes, align2, 1);
}
else
- assemble_integer (const0_rtx, pointer_bytes, 1);
+ assemble_integer (const0_rtx, pointer_bytes, align2, 1);
}
for (; i < count_basic_blocks; i++)
- assemble_integer (const0_rtx, pointer_bytes, 1);
+ assemble_integer (const0_rtx, pointer_bytes, align2, 1);
}
/* End with the address of the table of addresses,
if (profile_block_flag)
{
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3);
- assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes,
- 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
+ pointer_bytes, align2, 1);
}
}
}
data_section ();
ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
ASM_OUTPUT_INTERNAL_LABEL (file, "LP", profile_label_no);
- assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, 1);
+ assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, align, 1);
#endif
function_section (current_function_decl);
+2001-08-17 Richard Henderson <rth@redhat.com>
+
+ * class.c (emit_register_classes): Add align parameter to
+ call to assemble_integer.
+
2001-08-16 Alexandre Petit-Bianco <apbianco@redhat.com>
* jcf-parse.c (load_class): New locals saved and class_loaded. If
assemble_align (POINTER_SIZE);
for (t = registered_class; t; t = TREE_CHAIN (t))
assemble_integer (XEXP (DECL_RTL (t), 0),
- POINTER_SIZE / BITS_PER_UNIT, 1);
+ POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
#else
abort ();
#endif
extern void assemble_name PARAMS ((FILE *, const char *));
#ifdef RTX_CODE
-/* Assemble the integer constant X into an object of SIZE bytes.
- X must be either a CONST_INT or CONST_DOUBLE.
-
- Return 1 if we were able to output the constant, otherwise 0. If FORCE is
- non-zero, abort if we can't output the constant. */
-extern int assemble_integer PARAMS ((rtx, int, int));
-extern int assemble_eh_integer PARAMS ((rtx, int, int));
+/* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
+ the alignment of the integer in bits. Return 1 if we were able to output
+ the constant, otherwise 0. If FORCE is non-zero, abort if we can't output
+ the constant. */
+extern int assemble_integer PARAMS ((rtx, unsigned, unsigned, int));
#ifdef REAL_VALUE_TYPE
/* Assemble the floating-point constant D into an object of size MODE. */
extern void assemble_real PARAMS ((REAL_VALUE_TYPE,
- enum machine_mode));
+ enum machine_mode,
+ unsigned));
#endif
#endif
Assumes output_addressed_constants has been done on EXP already.
Generate exactly SIZE bytes of assembler data, padding at the end
- with zeros if necessary. SIZE must always be specified. */
-extern void output_constant PARAMS ((tree, int));
+ with zeros if necessary. SIZE must always be specified.
+
+ ALIGN is the alignment in bits that may be assumed for the data. */
+extern void output_constant PARAMS ((tree, int, unsigned));
#endif
#ifdef RTX_CODE
static int output_addressed_constants PARAMS ((tree));
static void output_after_function_constants PARAMS ((void));
static unsigned HOST_WIDE_INT array_size_for_constructor PARAMS ((tree));
-static void output_constructor PARAMS ((tree, int));
+static unsigned min_align PARAMS ((unsigned, unsigned));
+static void output_constructor PARAMS ((tree, int, unsigned));
#ifdef ASM_WEAKEN_LABEL
static void remove_from_pending_weak_list PARAMS ((const char *));
#endif
named_section_flags (section, SECTION_WRITE);
assemble_align (POINTER_SIZE);
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
}
#ifdef DTORS_SECTION_ASM_OP
int priority ATTRIBUTE_UNUSED;
{
dtors_section ();
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_align (POINTER_SIZE);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
}
#endif
}
named_section_flags (section, SECTION_WRITE);
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_align (POINTER_SIZE);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
}
#ifdef CTORS_SECTION_ASM_OP
int priority ATTRIBUTE_UNUSED;
{
ctors_section ();
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_align (POINTER_SIZE);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
}
#endif
\f
if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
{
int i;
-
- for (i = 0; i < size - 20; i += 20)
- {
-#ifdef ASM_BYTE_OP
- fprintf (asm_out_file,
- "%s0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n", ASM_BYTE_OP);
-#else
- fprintf (asm_out_file,
- "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
-#endif
- }
- if (i < size)
- {
-#ifdef ASM_BYTE_OP
- fprintf (asm_out_file, "%s0", ASM_BYTE_OP);
-#else
- fprintf (asm_out_file, "\tbyte 0");
-#endif
- i++;
- for (; i < size; i++)
- fprintf (asm_out_file, ",0");
- fprintf (asm_out_file, "\n");
- }
+ for (i = 0; i < size; i++)
+ assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
}
else
#endif
if (DECL_INITIAL (decl))
/* Output the actual data. */
output_constant (DECL_INITIAL (decl),
- tree_low_cst (DECL_SIZE_UNIT (decl), 1));
+ tree_low_cst (DECL_SIZE_UNIT (decl), 1),
+ align);
else
/* Leave space for it. */
assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
}
#endif
\f
-/* Assemble the integer constant X into an object of SIZE bytes.
- X must be either a CONST_INT or CONST_DOUBLE.
+/* A and B are either alignments or offsets. Return the minimum alignment
+ that may be assumed after adding the two together. */
+
+static inline unsigned
+min_align (a, b)
+ unsigned int a, b;
+{
+ return (a | b) & -(a | b);
+}
- Return 1 if we were able to output the constant, otherwise 0. If FORCE is
- non-zero, abort if we can't output the constant. */
+/* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
+ the alignment of the integer in bits. Return 1 if we were able to output
+ the constant, otherwise 0. If FORCE is non-zero, abort if we can't output
+ the constant. */
int
-assemble_integer (x, size, force)
+assemble_integer (x, size, align, force)
rtx x;
- int size;
+ unsigned int size;
+ unsigned int align;
int force;
{
/* First try to use the standard 1, 2, 4, 8, and 16 byte
ASM_OUTPUT... macros. */
- switch (size)
- {
+ if (align >= size * BITS_PER_UNIT)
+ switch (size)
+ {
#ifdef ASM_OUTPUT_CHAR
- case 1:
- ASM_OUTPUT_CHAR (asm_out_file, x);
- return 1;
+ case 1:
+ ASM_OUTPUT_CHAR (asm_out_file, x);
+ return 1;
#endif
-
#ifdef ASM_OUTPUT_SHORT
- case 2:
- ASM_OUTPUT_SHORT (asm_out_file, x);
- return 1;
+ case 2:
+ ASM_OUTPUT_SHORT (asm_out_file, x);
+ return 1;
#endif
-
#ifdef ASM_OUTPUT_INT
- case 4:
- ASM_OUTPUT_INT (asm_out_file, x);
- return 1;
+ case 4:
+ ASM_OUTPUT_INT (asm_out_file, x);
+ return 1;
#endif
-
#ifdef ASM_OUTPUT_DOUBLE_INT
- case 8:
- ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
- return 1;
+ case 8:
+ ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
+ return 1;
#endif
-
#ifdef ASM_OUTPUT_QUADRUPLE_INT
- case 16:
- ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
- return 1;
+ case 16:
+ ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
+ return 1;
+#endif
+ }
+ else
+ {
+ const char *asm_op = NULL;
+
+ switch (size)
+ {
+#ifdef UNALIGNED_SHORT_ASM_OP
+ case 2:
+ asm_op = UNALIGNED_SHORT_ASM_OP;
+ break;
+#endif
+#ifdef UNALIGNED_INT_ASM_OP
+ case 4:
+ asm_op = UNALIGNED_INT_ASM_OP;
+ break;
+#endif
+#ifdef UNALIGNED_DOUBLE_INT_ASM_OP
+ case 8:
+ asm_op = UNALIGNED_DOUBLE_INT_ASM_OP;
+ break;
#endif
+ }
+
+ if (asm_op)
+ {
+ fputs (asm_op, asm_out_file);
+ output_addr_const (asm_out_file, x);
+ fputc ('\n', asm_out_file);
+ return 1;
+ }
}
/* If we couldn't do it that way, there are two other possibilities: First,
}
#endif
- /* Finally, if SIZE is larger than a single word, try to output the constant
+ /* If SIZE is larger than a single word, try to output the constant
one word at a time. */
if (size > UNITS_PER_WORD)
{
- int i;
enum machine_mode mode
= mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
- rtx word;
+ unsigned align2 = min_align (align, BITS_PER_WORD);
+ unsigned int i;
for (i = 0; i < size / UNITS_PER_WORD; i++)
{
- word = operand_subword (x, i, 0, mode);
-
+ rtx word = operand_subword (x, i, 0, mode);
if (word == 0)
break;
-
- if (! assemble_integer (word, UNITS_PER_WORD, 0))
+ if (! assemble_integer (word, UNITS_PER_WORD, align2, 0))
break;
}
abort ();
}
+ /* If unaligned, and this is a constant, emit it one byte at a time. */
+ if (align < size * BITS_PER_UNIT)
+ {
+ enum machine_mode omode, imode;
+ unsigned int i;
+
+ omode = mode_for_size (BITS_PER_UNIT, MODE_INT, 0);
+ imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
+
+ for (i = 0; i < size; i++)
+ {
+ rtx byte = simplify_subreg (omode, x, imode, i);
+ if (byte == 0)
+ break;
+ if (! assemble_integer (byte, 1, BITS_PER_UNIT, 0))
+ break;
+ }
+
+ if (i == size)
+ return 1;
+ /* If we output at least one byte and then could not finish,
+ there is no valid way to continue. */
+ if (i > 0)
+ abort ();
+ }
+
if (force)
abort ();
}
void
-assemble_real (d, mode)
+assemble_real (d, mode, align)
REAL_VALUE_TYPE d;
enum machine_mode mode;
+ unsigned int align;
{
struct assemble_real_args args;
args.d = &d;
args.mode = mode;
+ /* We cannot emit unaligned floating point constants. This is slightly
+ complicated in that we don't know what "unaligned" means exactly. */
+#ifdef BIGGEST_FIELD_ALIGNMENT
+ if (align >= BIGGEST_FIELD_ALIGNMENT)
+ ;
+ else
+#endif
+ if (align < GET_MODE_ALIGNMENT (mode))
+ abort ();
+
if (do_float_handler (assemble_real_1, (PTR) &args))
return;
(TREE_CODE (exp) == STRING_CST
? MAX (TREE_STRING_LENGTH (exp),
int_size_in_bytes (TREE_TYPE (exp)))
- : int_size_in_bytes (TREE_TYPE (exp))));
+ : int_size_in_bytes (TREE_TYPE (exp))),
+ align);
}
\f
abort ();
memcpy ((char *) &u, (char *) &CONST_DOUBLE_LOW (x), sizeof u);
- assemble_real (u.d, pool->mode);
+ assemble_real (u.d, pool->mode, pool->align);
break;
case MODE_INT:
case MODE_PARTIAL_INT:
- assemble_integer (x, GET_MODE_SIZE (pool->mode), 1);
+ assemble_integer (x, GET_MODE_SIZE (pool->mode), pool->align, 1);
break;
default:
#ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
done: ;
#endif
-
}
#ifdef ASM_OUTPUT_POOL_EPILOGUE
There a case in which we would fail to output exactly SIZE bytes:
for a structure constructor that wants to produce more than SIZE bytes.
- But such constructors will never be generated for any possible input. */
+ But such constructors will never be generated for any possible input.
+
+ ALIGN is the alignment of the data in bits. */
void
-output_constant (exp, size)
- register tree exp;
- register int size;
+output_constant (exp, size, align)
+ tree exp;
+ int size;
+ unsigned int align;
{
register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
EXPAND_INITIALIZER),
- size, 0))
+ size, align, 0))
error ("initializer for integer value is too complicated");
size = 0;
break;
error ("initializer for floating value is not a floating constant");
assemble_real (TREE_REAL_CST (exp),
- mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0));
+ mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0),
+ align);
size = 0;
break;
case COMPLEX_TYPE:
- output_constant (TREE_REALPART (exp), size / 2);
- output_constant (TREE_IMAGPART (exp), size / 2);
+ output_constant (TREE_REALPART (exp), size / 2, align);
+ output_constant (TREE_IMAGPART (exp), size / 2,
+ min_align (align, BITS_PER_UNIT * (size / 2)));
size -= (size / 2) * 2;
break;
case ARRAY_TYPE:
if (TREE_CODE (exp) == CONSTRUCTOR)
{
- output_constructor (exp, size);
+ output_constructor (exp, size, align);
return;
}
else if (TREE_CODE (exp) == STRING_CST)
case RECORD_TYPE:
case UNION_TYPE:
if (TREE_CODE (exp) == CONSTRUCTOR)
- output_constructor (exp, size);
+ output_constructor (exp, size, align);
else
abort ();
return;
if (TREE_CODE (exp) == INTEGER_CST)
assemble_integer (expand_expr (exp, NULL_RTX,
VOIDmode, EXPAND_INITIALIZER),
- size, 1);
+ size, align, 1);
else if (TREE_CODE (exp) == CONSTRUCTOR)
{
unsigned char *buffer = (unsigned char *) alloca (size);
Generate at least SIZE bytes, padding if necessary. */
static void
-output_constructor (exp, size)
+output_constructor (exp, size, align)
tree exp;
int size;
+ unsigned int align;
{
tree type = TREE_TYPE (exp);
register tree link, field = 0;
HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
HOST_WIDE_INT index;
+ unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
for (index = lo_index; index <= hi_index; index++)
{
if (val == 0)
assemble_zeros (fieldsize);
else
- output_constant (val, fieldsize);
+ output_constant (val, fieldsize, align2);
/* Count its size. */
total_bytes += fieldsize;
/* Since this structure is static,
we know the positions are constant. */
HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
+ unsigned int align2;
if (index != 0)
pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
total_bytes = pos;
}
- else if (field != 0 && DECL_PACKED (field))
- /* Some assemblers automaticallly align a datum according to its
- size if no align directive is specified. The datum, however,
- may be declared with 'packed' attribute, so we have to disable
- such a feature. */
- ASM_OUTPUT_ALIGN (asm_out_file, 0);
-
+ /* Find the alignment of this element. */
+ align2 = min_align (align, BITS_PER_UNIT * pos);
+
/* Determine size this element should occupy. */
if (field)
{
if (val == 0)
assemble_zeros (fieldsize);
else
- output_constant (val, fieldsize);
+ output_constant (val, fieldsize, align2);
/* Count its size. */
total_bytes += fieldsize;
projects / thirdparty / gcc.git / commitdiff
