/* How to generate a relocation. */
#define hppa_gen_reloc_type hppa_elf_gen_reloc_type
-/* Who knows. */
+/* ELF objects can have versions, but apparently do not have anywhere
+ to store a copyright string. */
#define obj_version obj_elf_version
+#define obj_copyright obj_elf_version
/* Use space aliases. */
#define USE_ALIASES 1
/* Object file formats specify relocation types. */
typedef int reloc_type;
-/* Who knows. */
+/* SOM objects can have both a version string and a copyright string. */
#define obj_version obj_som_version
+#define obj_copyright obj_som_copyright
/* Do not use space aliases. */
#define USE_ALIASES 0
struct call_info
{
- /* Should sr3 be saved in the prologue? */
- int entry_sr;
-
- /* Does this function make calls? */
- int makes_calls;
-
/* The unwind descriptor being built. */
struct unwind_table ci_unwind;
/* (temporary) symbol used to mark the end of this function. */
symbolS *end_symbol;
- /* frags associated with start and end of this function. */
- fragS *start_frag;
- fragS *end_frag;
-
- /* frags for starting/ending offset of this descriptor. */
- fragS *start_offset_frag;
- fragS *end_offset_frag;
-
- /* The location within {start,end}_offset_frag to find the
- {start,end}_offset. */
- int start_frag_where;
- int end_frag_where;
-
- /* Fixups (relocations) for start_offset and end_offset. */
- fixS *start_fix;
- fixS *end_fix;
-
/* Next entry in the chain. */
struct call_info *ci_next;
};
an EXPORT or IMPORT directive. Only SOM uses this formation
(ELF has no need for it). */
typedef enum
-{
- SYMBOL_TYPE_UNKNOWN,
- SYMBOL_TYPE_ABSOLUTE,
- SYMBOL_TYPE_CODE,
- SYMBOL_TYPE_DATA,
- SYMBOL_TYPE_ENTRY,
- SYMBOL_TYPE_MILLICODE,
- SYMBOL_TYPE_PLABEL,
- SYMBOL_TYPE_PRI_PROG,
- SYMBOL_TYPE_SEC_PROG,
-} pa_symbol_type;
+ {
+ SYMBOL_TYPE_UNKNOWN,
+ SYMBOL_TYPE_ABSOLUTE,
+ SYMBOL_TYPE_CODE,
+ SYMBOL_TYPE_DATA,
+ SYMBOL_TYPE_ENTRY,
+ SYMBOL_TYPE_MILLICODE,
+ SYMBOL_TYPE_PLABEL,
+ SYMBOL_TYPE_PRI_PROG,
+ SYMBOL_TYPE_SEC_PROG,
+ }
+pa_symbol_type;
/* This structure contains information needed to assemble
individual instructions. */
struct subspace_dictionary_chain
{
- /* Index of containing space. */
- unsigned long ssd_space_index;
-
/* Nonzero if this space has been defined by the user code. */
unsigned int ssd_defined;
- /* Which quadrant within the space this subspace should be loaded into. */
- unsigned char ssd_quadrant;
-
- /* Alignment (in bytes) for this subspace. */
- unsigned long ssd_alignment;
-
- /* Access control bits to determine read/write/execute permissions
- as well as gateway privilege promotions. */
- unsigned char ssd_access_control_bits;
-
- /* A sorting key so that it is possible to specify ordering of
- subspaces within a space. */
- unsigned char ssd_sort_key;
-
- /* Nonzero of this space should be zero filled. */
- unsigned long ssd_zero;
-
- /* Nonzero if this is a common subspace. */
- unsigned char ssd_common;
-
- /* Nonzero if this is a common subspace which allows symbols to be
- multiply defined. */
- unsigned char ssd_dup_common;
-
- /* Nonzero if this subspace is loadable. Note loadable subspaces
- must be contained within loadable spaces; unloadable subspaces
- must be contained in unloadable spaces. */
- unsigned char ssd_loadable;
-
- /* Nonzero if this subspace contains only code. */
- unsigned char ssd_code_only;
-
- /* Starting offset of this subspace. */
- unsigned long ssd_subspace_start;
-
- /* Length of this subspace. */
- unsigned long ssd_subspace_length;
-
/* Name of this subspace. */
char *ssd_name;
asection *ssd_seg;
int ssd_subseg;
- /* Index of this subspace within the subspace dictionary of the object
- file. Not used until object file is written. */
- int object_file_index;
-
- /* The size of the last alignment request for this subspace. */
- int ssd_last_align;
-
/* Next space in the subspace dictionary chain. */
struct subspace_dictionary_chain *ssd_next;
};
struct space_dictionary_chain
{
-
- /* Holds the index into the string table of the name of this
- space. */
- unsigned int sd_name_index;
-
- /* Nonzero if the space is loadable. */
- unsigned int sd_loadable;
-
/* Nonzero if this space has been defined by the user code or
as a default space. */
unsigned int sd_defined;
/* Nonzero if this spaces has been defined by the user code. */
unsigned int sd_user_defined;
- /* Nonzero if this space is not sharable. */
- unsigned int sd_private;
-
/* The space number (or index). */
unsigned int sd_spnum;
- /* The sort key for this space. May be used to determine how to lay
- out the spaces within the object file. */
- unsigned char sd_sort_key;
-
/* The name of this subspace. */
char *sd_name;
struct default_subspace_dict
{
- /* Name of the subspace. */
+ /* Name of the subspace. */
char *name;
/* FIXME. Is this still needed? */
/* Extra information needed to perform fixups (relocations) on the PA. */
struct hppa_fix_struct
-{
+ {
/* The field selector. */
- int fx_r_field;
+ enum hppa_reloc_field_selector_type fx_r_field;
/* Type of fixup. */
int fx_r_type;
/* The unwind descriptor associated with this fixup. */
char fx_unwind[8];
-};
+ };
/* Structure to hold information about predefined registers. */
struct pd_reg
-{
- char *name;
- int value;
-};
+ {
+ char *name;
+ int value;
+ };
/* This structure defines the mapping from a FP condition string
to a condition number which can be recorded in an instruction. */
struct fp_cond_map
-{
- char *string;
- int cond;
-};
+ {
+ char *string;
+ int cond;
+ };
/* This structure defines a mapping from a field selector
string to a field selector type. */
struct selector_entry
-{
- char *prefix;
- int field_selector;
-};
+ {
+ char *prefix;
+ int field_selector;
+ };
/* Prototypes for functions local to tc-hppa.c. */
static fp_operand_format pa_parse_fp_format PARAMS ((char **s));
static void pa_cons PARAMS ((int));
static void pa_data PARAMS ((int));
-static void pa_desc PARAMS ((int));
static void pa_float_cons PARAMS ((int));
static void pa_fill PARAMS ((int));
static void pa_lcomm PARAMS ((int));
static void pa_version PARAMS ((int));
static int pa_parse_fp_cmp_cond PARAMS ((char **));
static int get_expression PARAMS ((char *));
-static int pa_get_absolute_expression PARAMS ((char *));
-static int evaluate_absolute PARAMS ((expressionS, int));
+static int pa_get_absolute_expression PARAMS ((struct pa_it *, char **));
+static int evaluate_absolute PARAMS ((struct pa_it *));
static unsigned int pa_build_arg_reloc PARAMS ((char *));
static unsigned int pa_align_arg_reloc PARAMS ((unsigned int, unsigned int));
static int pa_parse_nullif PARAMS ((char **));
static void pa_equ PARAMS ((int));
static void pa_exit PARAMS ((int));
static void pa_export PARAMS ((int));
-static void pa_export_args PARAMS ((symbolS *));
+static void pa_type_args PARAMS ((symbolS *, int));
static void pa_import PARAMS ((int));
static void pa_label PARAMS ((int));
static void pa_leave PARAMS ((int));
static void pa_subspace PARAMS ((int));
static void pa_param PARAMS ((int));
static void pa_undefine_label PARAMS ((void));
-static int need_89_opcode PARAMS ((struct pa_it *,
+static int need_89_opcode PARAMS ((struct pa_it *,
struct pa_89_fp_reg_struct *));
static int pa_parse_number PARAMS ((char **, struct pa_89_fp_reg_struct *));
static label_symbol_struct *pa_get_label PARAMS ((void));
static sd_chain_struct *create_new_space PARAMS ((char *, int, char,
char, char, char,
asection *, int));
-static ssd_chain_struct * create_new_subspace PARAMS ((sd_chain_struct *,
- char *, char, char,
- char, char, char,
- char, int, int, int,
- int, asection *));
+static ssd_chain_struct *create_new_subspace PARAMS ((sd_chain_struct *,
+ char *, char, char,
+ char, char, char,
+ char, int, int, int,
+ int, asection *));
static ssd_chain_struct *update_subspace PARAMS ((sd_chain_struct *,
char *, char, char, char,
char, char, char, int,
static sd_chain_struct *is_defined_space PARAMS ((char *));
static ssd_chain_struct *is_defined_subspace PARAMS ((char *));
static sd_chain_struct *pa_segment_to_space PARAMS ((asection *));
-static ssd_chain_struct * pa_subsegment_to_subspace PARAMS ((asection *,
- subsegT));
+static ssd_chain_struct *pa_subsegment_to_subspace PARAMS ((asection *,
+ subsegT));
static sd_chain_struct *pa_find_space_by_number PARAMS ((int));
static unsigned int pa_subspace_start PARAMS ((sd_chain_struct *, int));
static void pa_ip PARAMS ((char *));
static void fix_new_hppa PARAMS ((fragS *, int, short int, symbolS *,
long, expressionS *, int,
- bfd_reloc_code_real_type, long,
+ bfd_reloc_code_real_type,
+ enum hppa_reloc_field_selector_type,
int, long, char *));
-static void md_apply_fix_1 PARAMS ((fixS *, long));
static int is_end_of_statement PARAMS ((void));
static int reg_name_search PARAMS ((char *));
static int pa_chk_field_selector PARAMS ((char **));
static void pa_build_unwind_subspace PARAMS ((struct call_info *));
static void process_exit PARAMS ((void));
static sd_chain_struct *pa_parse_space_stmt PARAMS ((char *, int));
-static void pa_align_subseg PARAMS ((asection *, subsegT));
static int log2 PARAMS ((int));
static int pa_next_subseg PARAMS ((sd_chain_struct *));
static unsigned int pa_stringer_aux PARAMS ((char *));
static void pa_spaces_begin PARAMS ((void));
-
+static void hppa_elf_mark_end_of_function PARAMS ((void));
/* File and gloally scoped variable declarations. */
function labels. */
static struct call_info *last_call_info;
-/* The last call description (for actual calls). */
+/* The last call description (for actual calls). */
static struct call_desc last_call_desc;
/* Relaxation isn't supported for the PA yet. */
-const relax_typeS md_relax_table[] = {0};
+const relax_typeS md_relax_table[] =
+{0};
-/* Jumps are always the same size -- one instruction. */
+/* Jumps are always the same size -- one instruction. */
int md_short_jump_size = 4;
int md_long_jump_size = 4;
{"COPYRIGHT", pa_copyright, 0},
{"data", pa_data, 0},
{"DATA", pa_data, 0},
- {"desc", pa_desc, 0},
- {"DESC", pa_desc, 0},
{"double", pa_float_cons, 'd'},
{"DOUBLE", pa_float_cons, 'd'},
{"end", pa_end, 0},
/* Nonzero if the assembler is currently within a .entry/.exit pair. */
static int within_entry_exit;
-/* Nonzero if the assembler has completed exit processing for the
- current procedure. */
-static int exit_processing_complete;
-
/* Nonzero if the assembler is currently within a procedure definition. */
static int within_procedure;
/* Holds the last field selector. */
static int hppa_field_selector;
+/* A dummy bfd symbol so that all relocations have symbols of some kind. */
+static asymbol *dummy_symbol;
+
/* Nonzero if errors are to be printed. */
static int print_errors = 1;
{"%eiem", 15},
{"%eirr", 23},
{"%fr0", 0},
- {"%fr0L", 0},
- {"%fr0R", 0},
+ {"%fr0l", 0},
+ {"%fr0r", 0},
{"%fr1", 1},
{"%fr10", 10},
- {"%fr10L", 10},
- {"%fr10R", 10},
+ {"%fr10l", 10},
+ {"%fr10r", 10},
{"%fr11", 11},
- {"%fr11L", 11},
- {"%fr11R", 11},
+ {"%fr11l", 11},
+ {"%fr11r", 11},
{"%fr12", 12},
- {"%fr12L", 12},
- {"%fr12R", 12},
+ {"%fr12l", 12},
+ {"%fr12r", 12},
{"%fr13", 13},
- {"%fr13L", 13},
- {"%fr13R", 13},
+ {"%fr13l", 13},
+ {"%fr13r", 13},
{"%fr14", 14},
- {"%fr14L", 14},
- {"%fr14R", 14},
+ {"%fr14l", 14},
+ {"%fr14r", 14},
{"%fr15", 15},
- {"%fr15L", 15},
- {"%fr15R", 15},
+ {"%fr15l", 15},
+ {"%fr15r", 15},
{"%fr16", 16},
- {"%fr16L", 16},
- {"%fr16R", 16},
+ {"%fr16l", 16},
+ {"%fr16r", 16},
{"%fr17", 17},
- {"%fr17L", 17},
- {"%fr17R", 17},
+ {"%fr17l", 17},
+ {"%fr17r", 17},
{"%fr18", 18},
- {"%fr18L", 18},
- {"%fr18R", 18},
+ {"%fr18l", 18},
+ {"%fr18r", 18},
{"%fr19", 19},
- {"%fr19L", 19},
- {"%fr19R", 19},
- {"%fr1L", 1},
- {"%fr1R", 1},
+ {"%fr19l", 19},
+ {"%fr19r", 19},
+ {"%fr1l", 1},
+ {"%fr1r", 1},
{"%fr2", 2},
{"%fr20", 20},
- {"%fr20L", 20},
- {"%fr20R", 20},
+ {"%fr20l", 20},
+ {"%fr20r", 20},
{"%fr21", 21},
- {"%fr21L", 21},
- {"%fr21R", 21},
+ {"%fr21l", 21},
+ {"%fr21r", 21},
{"%fr22", 22},
- {"%fr22L", 22},
- {"%fr22R", 22},
+ {"%fr22l", 22},
+ {"%fr22r", 22},
{"%fr23", 23},
- {"%fr23L", 23},
- {"%fr23R", 23},
+ {"%fr23l", 23},
+ {"%fr23r", 23},
{"%fr24", 24},
- {"%fr24L", 24},
- {"%fr24R", 24},
+ {"%fr24l", 24},
+ {"%fr24r", 24},
{"%fr25", 25},
- {"%fr25L", 25},
- {"%fr25R", 25},
+ {"%fr25l", 25},
+ {"%fr25r", 25},
{"%fr26", 26},
- {"%fr26L", 26},
- {"%fr26R", 26},
+ {"%fr26l", 26},
+ {"%fr26r", 26},
{"%fr27", 27},
- {"%fr27L", 27},
- {"%fr27R", 27},
+ {"%fr27l", 27},
+ {"%fr27r", 27},
{"%fr28", 28},
- {"%fr28L", 28},
- {"%fr28R", 28},
+ {"%fr28l", 28},
+ {"%fr28r", 28},
{"%fr29", 29},
- {"%fr29L", 29},
- {"%fr29R", 29},
- {"%fr2L", 2},
- {"%fr2R", 2},
+ {"%fr29l", 29},
+ {"%fr29r", 29},
+ {"%fr2l", 2},
+ {"%fr2r", 2},
{"%fr3", 3},
{"%fr30", 30},
- {"%fr30L", 30},
- {"%fr30R", 30},
+ {"%fr30l", 30},
+ {"%fr30r", 30},
{"%fr31", 31},
- {"%fr31L", 31},
- {"%fr31R", 31},
- {"%fr3L", 3},
- {"%fr3R", 3},
+ {"%fr31l", 31},
+ {"%fr31r", 31},
+ {"%fr3l", 3},
+ {"%fr3r", 3},
{"%fr4", 4},
- {"%fr4L", 4},
- {"%fr4R", 4},
+ {"%fr4l", 4},
+ {"%fr4r", 4},
{"%fr5", 5},
- {"%fr5L", 5},
- {"%fr5R", 5},
+ {"%fr5l", 5},
+ {"%fr5r", 5},
{"%fr6", 6},
- {"%fr6L", 6},
- {"%fr6R", 6},
+ {"%fr6l", 6},
+ {"%fr6r", 6},
{"%fr7", 7},
- {"%fr7L", 7},
- {"%fr7R", 7},
+ {"%fr7l", 7},
+ {"%fr7r", 7},
{"%fr8", 8},
- {"%fr8L", 8},
- {"%fr8R", 8},
+ {"%fr8l", 8},
+ {"%fr8r", 8},
{"%fr9", 9},
- {"%fr9L", 9},
- {"%fr9R", 9},
+ {"%fr9l", 9},
+ {"%fr9r", 9},
{"%hta", 25},
{"%iir", 19},
{"%ior", 21},
{"%r30", 30},
{"%r31", 31},
{"%r4", 4},
- {"%r4L", 4},
- {"%r4R", 4},
{"%r5", 5},
- {"%r5L", 5},
- {"%r5R", 5},
{"%r6", 6},
- {"%r6L", 6},
- {"%r6R", 6},
{"%r7", 7},
- {"%r7L", 7},
- {"%r7R", 7},
{"%r8", 8},
- {"%r8L", 8},
- {"%r8R", 8},
{"%r9", 9},
- {"%r9L", 9},
- {"%r9R", 9},
{"%rctr", 0},
{"%ret0", 28},
{"%ret1", 29},
/* This table is sorted by order of the length of the string. This is
so we check for <> before we check for <. If we had a <> and checked
for < first, we would get a false match. */
-static const struct fp_cond_map fp_cond_map [] =
+static const struct fp_cond_map fp_cond_map[] =
{
{"false?", 0},
{"false", 1},
static const struct selector_entry selector_table[] =
{
- {"F'", e_fsel},
- {"F%", e_fsel},
- {"LS'", e_lssel},
- {"LS%", e_lssel},
- {"RS'", e_rssel},
- {"RS%", e_rssel},
- {"L'", e_lsel},
- {"L%", e_lsel},
- {"R'", e_rsel},
- {"R%", e_rsel},
- {"LD'", e_ldsel},
- {"LD%", e_ldsel},
- {"RD'", e_rdsel},
- {"RD%", e_rdsel},
- {"LR'", e_lrsel},
- {"LR%", e_lrsel},
- {"RR'", e_rrsel},
- {"RR%", e_rrsel},
- {"P'", e_psel},
- {"P%", e_psel},
- {"RP'", e_rpsel},
- {"RP%", e_rpsel},
- {"LP'", e_lpsel},
- {"LP%", e_lpsel},
- {"T'", e_tsel},
- {"T%", e_tsel},
- {"RT'", e_rtsel},
- {"RT%", e_rtsel},
- {"LT'", e_ltsel},
- {"LT%", e_ltsel},
- {NULL, e_fsel}
+ {"f", e_fsel},
+ {"l", e_lsel},
+ {"ld", e_ldsel},
+ {"lp", e_lpsel},
+ {"lr", e_lrsel},
+ {"ls", e_lssel},
+ {"lt", e_ltsel},
+ {"p", e_psel},
+ {"r", e_rsel},
+ {"rd", e_rdsel},
+ {"rp", e_rpsel},
+ {"rr", e_rrsel},
+ {"rs", e_rssel},
+ {"rt", e_rtsel},
+ {"t", e_tsel},
};
/* default space and subspace dictionaries */
{"$DATA$", 1, 1, 0, 0, 0, 0, 24, 0x1f, 1, 8, 1, 1, ".data", SUBSEG_DATA},
{"$LIT$", 1, 1, 0, 0, 0, 0, 16, 0x2c, 0, 8, 0, 0, ".text", SUBSEG_LIT},
{"$BSS$", 1, 1, 0, 0, 0, 1, 80, 0x1f, 1, 8, 1, 1, ".bss", SUBSEG_BSS},
+#ifdef OBJ_ELF
{"$UNWIND$", 1, 1, 0, 0, 0, 0, 64, 0x2c, 0, 4, 0, 0, ".hppa_unwind", SUBSEG_UNWIND},
+#endif
{NULL, 0, 1, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, 0, 0}
};
/* These macros are used to maintain spaces/subspaces. */
#define SPACE_DEFINED(space_chain) (space_chain)->sd_defined
#define SPACE_USER_DEFINED(space_chain) (space_chain)->sd_user_defined
-#define SPACE_PRIVATE(space_chain) (space_chain)->sd_private
-#define SPACE_LOADABLE(space_chain) (space_chain)->sd_loadable
#define SPACE_SPNUM(space_chain) (space_chain)->sd_spnum
-#define SPACE_SORT(space_chain) (space_chain)->sd_sort_key
#define SPACE_NAME(space_chain) (space_chain)->sd_name
-#define SPACE_NAME_INDEX(space_chain) (space_chain)->sd_name_index
-#define SUBSPACE_SPACE_INDEX(ss_chain) (ss_chain)->ssd_space_index
#define SUBSPACE_DEFINED(ss_chain) (ss_chain)->ssd_defined
-#define SUBSPACE_QUADRANT(ss_chain) (ss_chain)->ssd_quadrant
-#define SUBSPACE_ALIGN(ss_chain) (ss_chain)->ssd_alignment
-#define SUBSPACE_ACCESS(ss_chain) (ss_chain)->ssd_access_control_bits
-#define SUBSPACE_SORT(ss_chain) (ss_chain)->ssd_sort_key
-#define SUBSPACE_COMMON(ss_chain) (ss_chain)->ssd_common
-#define SUBSPACE_ZERO(ss_chain) (ss_chain)->ssd_zero
-#define SUBSPACE_DUP_COMM(ss_chain) (ss_chain)->ssd_dup_common
-#define SUBSPACE_CODE_ONLY(ss_chain) (ss_chain)->ssd_code_only
-#define SUBSPACE_LOADABLE(ss_chain) (ss_chain)->ssd_loadable
-#define SUBSPACE_SUBSPACE_START(ss_chain) (ss_chain)->ssd_subspace_start
-#define SUBSPACE_SUBSPACE_LENGTH(ss_chain) (ss_chain)->ssd_subspace_length
#define SUBSPACE_NAME(ss_chain) (ss_chain)->ssd_name
+/* Insert FIELD into OPCODE starting at bit START. Continue pa_ip
+ main loop after insertion. */
+
+#define INSERT_FIELD_AND_CONTINUE(OPCODE, FIELD, START) \
+ { \
+ ((OPCODE) |= (FIELD) << (START)); \
+ continue; \
+ }
+
+/* Simple range checking for FIELD againt HIGH and LOW bounds.
+ IGNORE is used to suppress the error message. */
+
+#define CHECK_FIELD(FIELD, HIGH, LOW, IGNORE) \
+ { \
+ if ((FIELD) > (HIGH) || (FIELD) < (LOW)) \
+ { \
+ if (! IGNORE) \
+ as_bad ("Field out of range [%d..%d] (%d).", (LOW), (HIGH), \
+ (int) (FIELD));\
+ break; \
+ } \
+ }
+
#define is_DP_relative(exp) \
((exp).X_op == O_subtract \
&& strcmp((exp).X_op_symbol->bsym->name, "$global$") == 0)
expressionS *exp;
int pcrel;
bfd_reloc_code_real_type r_type;
- long r_field;
+ enum hppa_reloc_field_selector_type r_field;
int r_format;
long arg_reloc;
char *unwind_desc;
fixS *new_fix;
struct hppa_fix_struct *hppa_fix = (struct hppa_fix_struct *)
- obstack_alloc (¬es, sizeof (struct hppa_fix_struct));
+ obstack_alloc (¬es, sizeof (struct hppa_fix_struct));
if (exp != NULL)
new_fix = fix_new_exp (frag, where, size, exp, pcrel, r_type);
bcopy (unwind_desc, hppa_fix->fx_unwind, 8);
/* If necessary call BFD backend function to attach the
- unwind bits to the target dependent parts of a BFD symbol.
- Yuk. */
+ unwind bits to the target dependent parts of a BFD symbol.
+ Yuk. */
#ifdef obj_attach_unwind_info
obj_attach_unwind_info (add_symbol->bsym, unwind_desc);
#endif
/* foo-$global$ is used to access non-automatic storage. $global$
is really just a marker and has served its purpose, so eliminate
it now so as not to confuse write.c. */
- if (!strcmp (S_GET_NAME (new_fix->fx_subsy), "$global$"))
+ if (new_fix->fx_subsy
+ && !strcmp (S_GET_NAME (new_fix->fx_subsy), "$global$"))
new_fix->fx_subsy = NULL;
}
int size;
expressionS *exp;
{
- unsigned int reloc_type;
+ unsigned int rel_type;
if (is_DP_relative (*exp))
- reloc_type = R_HPPA_GOTOFF;
+ rel_type = R_HPPA_GOTOFF;
else if (is_complex (*exp))
- reloc_type = R_HPPA_COMPLEX;
+ rel_type = R_HPPA_COMPLEX;
else
- reloc_type = R_HPPA;
+ rel_type = R_HPPA;
if (hppa_field_selector != e_psel && hppa_field_selector != e_fsel)
as_warn ("Invalid field selector. Assuming F%%.");
fix_new_hppa (frag, where, size,
- (symbolS *) NULL, (offsetT) 0, exp, 0, reloc_type,
+ (symbolS *) NULL, (offsetT) 0, exp, 0, rel_type,
hppa_field_selector, 32, 0, (char *) 0);
/* Reset field selector to its default state. */
pa_spaces_begin ();
op_hash = hash_new ();
- if (op_hash == NULL)
- as_fatal ("Virtual memory exhausted");
while (i < NUMOPCODES)
{
const char *name = pa_opcodes[i].name;
- retval = hash_insert (op_hash, name, (struct pa_opcode *)&pa_opcodes[i]);
+ retval = hash_insert (op_hash, name, (struct pa_opcode *) &pa_opcodes[i]);
if (retval != NULL && *retval != '\0')
{
as_fatal ("Internal error: can't hash `%s': %s\n", name, retval);
}
do
{
- if ((pa_opcodes[i].match & pa_opcodes[i].mask)
+ if ((pa_opcodes[i].match & pa_opcodes[i].mask)
!= pa_opcodes[i].match)
{
fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
/* SOM will change text_section. To make sure we never put
anything into the old one switch to the new one now. */
subseg_set (text_section, 0);
-}
-
-/* Called at the end of assembling a source file. Nothing to do
- at this point on the PA. */
-void
-md_end ()
-{
- return;
+ dummy_symbol = symbol_find_or_make ("L$dummy");
+ dummy_symbol->section = text_section;
}
/* Assemble a single instruction storing it into a frag. */
/* The had better be something to assemble. */
assert (str);
+ /* If we are within a procedure definition, make sure we've
+ defined a label for the procedure; handle case where the
+ label was defined after the .PROC directive. */
+ if (within_procedure && last_call_info->start_symbol == NULL)
+ {
+ label_symbol_struct *label_symbol = pa_get_label ();
+
+ if (label_symbol)
+ {
+ if (label_symbol->lss_label)
+ {
+ last_call_info->start_symbol = label_symbol->lss_label;
+ label_symbol->lss_label->bsym->flags |= BSF_FUNCTION;
+ }
+ else
+ as_bad ("Missing function name for .PROC (corrupted label chain)");
+ }
+ else
+ as_bad ("Missing function name for .PROC");
+ }
+
/* Assemble the instruction. Results are saved into "the_insn". */
pa_ip (str);
(offsetT) 0, &the_insn.exp, the_insn.pcrel,
the_insn.reloc, the_insn.field_selector,
the_insn.format, the_insn.arg_reloc, NULL);
-
}
/* Do the real work for assembling a single instruction. Store results
- into the global "the_insn" variable.
-
- FIXME: Should define and use some functions/macros to handle
- various common insertions of information into the opcode. */
+ into the global "the_insn" variable. */
static void
pa_ip (str)
const char *args;
int match = FALSE;
int comma = 0;
- int reg, s2, s3, m, a, uu, cmpltr, nullif, flag, sfu, cond;
- unsigned int im21, im14, im11, im5;
- unsigned long i, opcode;
+ int cmpltr, nullif, flag, cond, num;
+ unsigned long opcode;
struct pa_opcode *insn;
/* Skip to something interesting. */
/* Handle a 5 bit register or control register field at 10. */
case 'b':
case '^':
- reg = pa_parse_number (&s, 0);
- if (reg < 32 && reg >= 0)
- {
- opcode |= reg << 21;
- continue;
- }
- break;
+ num = pa_parse_number (&s, 0);
+ CHECK_FIELD (num, 31, 0, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
/* Handle a 5 bit register field at 15. */
case 'x':
- reg = pa_parse_number (&s, 0);
- if (reg < 32 && reg >= 0)
- {
- opcode |= reg << 16;
- continue;
- }
- break;
+ num = pa_parse_number (&s, 0);
+ CHECK_FIELD (num, 31, 0, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
/* Handle a 5 bit register field at 31. */
case 'y':
case 't':
- reg = pa_parse_number (&s, 0);
- if (reg < 32 && reg >= 0)
- {
- opcode |= reg;
- continue;
- }
- break;
+ num = pa_parse_number (&s, 0);
+ CHECK_FIELD (num, 31, 0, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
/* Handle a 5 bit field length at 31. */
case 'T':
- pa_get_absolute_expression (s);
- if (the_insn.exp.X_op == O_constant)
- {
- reg = the_insn.exp.X_add_number;
- if (reg <= 32 && reg > 0)
- {
- opcode |= 32 - reg;
- s = expr_end;
- continue;
- }
- }
- break;
+ num = pa_get_absolute_expression (&the_insn, &s);
+ s = expr_end;
+ CHECK_FIELD (num, 32, 1, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, 32 - num, 0);
/* Handle a 5 bit immediate at 15. */
case '5':
- pa_get_absolute_expression (s);
- if (the_insn.exp.X_add_number > 15)
- {
- as_bad ("5 bit immediate > 15. Set to 15");
- the_insn.exp.X_add_number = 15;
- }
- else if (the_insn.exp.X_add_number < -16)
- {
- as_bad ("5 bit immediate < -16. Set to -16");
- the_insn.exp.X_add_number = -16;
- }
+ num = pa_get_absolute_expression (&the_insn, &s);
+ s = expr_end;
+ CHECK_FIELD (num, 15, -16, 0);
+ low_sign_unext (num, 5, &num);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
- low_sign_unext (evaluate_absolute (the_insn.exp,
- the_insn.field_selector),
- 5, &im5);
- opcode |= (im5 << 16);
+ /* Handle a 5 bit immediate at 31. */
+ case 'V':
+ num = pa_get_absolute_expression (&the_insn, &s);
s = expr_end;
- continue;
+ CHECK_FIELD (num, 15, -16, 0)
+ low_sign_unext (num, 5, &num);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
+
+ /* Handle an unsigned 5 bit immediate at 31. */
+ case 'r':
+ num = pa_get_absolute_expression (&the_insn, &s);
+ s = expr_end;
+ CHECK_FIELD (num, 31, 0, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
+
+ /* Handle an unsigned 5 bit immediate at 15. */
+ case 'R':
+ num = pa_get_absolute_expression (&the_insn, &s);
+ s = expr_end;
+ CHECK_FIELD (num, 31, 0, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
/* Handle a 2 bit space identifier at 17. */
case 's':
- s2 = pa_parse_number (&s, 0);
- if (s2 < 4 && s2 >= 0)
- {
- opcode |= s2 << 14;
- continue;
- }
- break;
+ num = pa_parse_number (&s, 0);
+ CHECK_FIELD (num, 3, 0, 1);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 14);
/* Handle a 3 bit space identifier at 18. */
case 'S':
- s3 = pa_parse_number (&s, 0);
- if (s3 < 8 && s3 >= 0)
- {
- dis_assemble_3 (s3, &s3);
- opcode |= s3 << 13;
- continue;
- }
- break;
+ num = pa_parse_number (&s, 0);
+ CHECK_FIELD (num, 7, 0, 1);
+ dis_assemble_3 (num, &num);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
/* Handle a completer for an indexing load or store. */
case 'c':
- uu = 0;
- m = 0;
- i = 0;
- while (*s == ',' && i < 2)
- {
- s++;
- if (strncasecmp (s, "sm", 2) == 0)
- {
- uu = 1;
+ {
+ int uu = 0;
+ int m = 0;
+ int i = 0;
+ while (*s == ',' && i < 2)
+ {
+ s++;
+ if (strncasecmp (s, "sm", 2) == 0)
+ {
+ uu = 1;
+ m = 1;
+ s++;
+ i++;
+ }
+ else if (strncasecmp (s, "m", 1) == 0)
m = 1;
- s++;
- i++;
- }
- else if (strncasecmp (s, "m", 1) == 0)
- m = 1;
- else if (strncasecmp (s, "s", 1) == 0)
- uu = 1;
- else
- as_bad ("Invalid Indexed Load Completer.");
- s++;
- i++;
- }
- if (i > 2)
- as_bad ("Invalid Indexed Load Completer Syntax.");
- while (*s == ' ' || *s == '\t')
- s++;
-
- opcode |= m << 5;
- opcode |= uu << 13;
- continue;
+ else if (strncasecmp (s, "s", 1) == 0)
+ uu = 1;
+ else
+ as_bad ("Invalid Indexed Load Completer.");
+ s++;
+ i++;
+ }
+ if (i > 2)
+ as_bad ("Invalid Indexed Load Completer Syntax.");
+ opcode |= m << 5;
+ INSERT_FIELD_AND_CONTINUE (opcode, uu, 13);
+ }
/* Handle a short load/store completer. */
case 'C':
- a = 0;
- m = 0;
- if (*s == ',')
- {
- s++;
- if (strncasecmp (s, "ma", 2) == 0)
- {
- a = 0;
- m = 1;
- }
- else if (strncasecmp (s, "mb", 2) == 0)
- {
- a = 1;
- m = 1;
- }
- else
- as_bad ("Invalid Short Load/Store Completer.");
- s += 2;
- }
- while (*s == ' ' || *s == '\t')
- s++;
- opcode |= m << 5;
- opcode |= a << 13;
- continue;
+ {
+ int a = 0;
+ int m = 0;
+ if (*s == ',')
+ {
+ s++;
+ if (strncasecmp (s, "ma", 2) == 0)
+ {
+ a = 0;
+ m = 1;
+ }
+ else if (strncasecmp (s, "mb", 2) == 0)
+ {
+ a = 1;
+ m = 1;
+ }
+ else
+ as_bad ("Invalid Short Load/Store Completer.");
+ s += 2;
+ }
+ opcode |= m << 5;
+ INSERT_FIELD_AND_CONTINUE (opcode, a, 13);
+ }
/* Handle a stbys completer. */
case 'Y':
- a = 0;
- m = 0;
- i = 0;
- while (*s == ',' && i < 2)
- {
- s++;
- if (strncasecmp (s, "m", 1) == 0)
- m = 1;
- else if (strncasecmp (s, "b", 1) == 0)
- a = 0;
- else if (strncasecmp (s, "e", 1) == 0)
- a = 1;
- else
- as_bad ("Invalid Store Bytes Short Completer");
- s++;
- i++;
- }
- if (i > 2)
- as_bad ("Invalid Store Bytes Short Completer");
- while (*s == ' ' || *s == '\t')
- s++;
- opcode |= m << 5;
- opcode |= a << 13;
- continue;
+ {
+ int a = 0;
+ int m = 0;
+ int i = 0;
+ while (*s == ',' && i < 2)
+ {
+ s++;
+ if (strncasecmp (s, "m", 1) == 0)
+ m = 1;
+ else if (strncasecmp (s, "b", 1) == 0)
+ a = 0;
+ else if (strncasecmp (s, "e", 1) == 0)
+ a = 1;
+ else
+ as_bad ("Invalid Store Bytes Short Completer");
+ s++;
+ i++;
+ }
+ if (i > 2)
+ as_bad ("Invalid Store Bytes Short Completer");
+ opcode |= m << 5;
+ INSERT_FIELD_AND_CONTINUE (opcode, a, 13);
+ }
/* Handle a non-negated compare/stubtract condition. */
case '<':
as_bad ("Invalid Compare/Subtract Condition: %c", *s);
cmpltr = 0;
}
- opcode |= cmpltr << 13;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
/* Handle a negated or non-negated compare/subtract condition. */
case '?':
opcode |= 1 << 27;
}
}
- opcode |= cmpltr << 13;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
/* Handle a negated or non-negated add condition. */
case '!':
opcode |= 1 << 27;
}
}
- opcode |= cmpltr << 13;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
/* Handle a compare/subtract condition. */
case 'a':
}
}
opcode |= cmpltr << 13;
- opcode |= flag << 12;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
/* Handle a non-negated add condition. */
case 'd':
cmpltr = 0;
flag = 1;
}
- else if (strcasecmp (name, "<>") == 0)
+ else if (strcmp (name, "<>") == 0)
{
cmpltr = 1;
flag = 1;
}
- else if (strcasecmp (name, ">=") == 0)
+ else if (strcmp (name, ">=") == 0)
{
cmpltr = 2;
flag = 1;
}
- else if (strcasecmp (name, ">") == 0)
+ else if (strcmp (name, ">") == 0)
{
cmpltr = 3;
flag = 1;
nullif = pa_parse_nullif (&s);
opcode |= nullif << 1;
opcode |= cmpltr << 13;
- opcode |= flag << 12;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
- /* Handle a logical instruction condition. */
+ /* HANDLE a logical instruction condition. */
case '&':
cmpltr = 0;
flag = 0;
*s = c;
}
opcode |= cmpltr << 13;
- opcode |= flag << 12;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
/* Handle a unit instruction condition. */
case 'U':
as_bad ("Invalid Logical Instruction Condition.");
}
opcode |= cmpltr << 13;
- opcode |= flag << 12;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
/* Handle a shift/extract/deposit condition. */
case '|':
as_bad ("Invalid Shift/Extract/Deposit Condition.");
*s = c;
}
- opcode |= cmpltr << 13;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
/* Handle bvb and bb conditions. */
case '~':
else
as_bad ("Invalid Bit Branch Condition: %c", *s);
}
- opcode |= cmpltr << 13;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
- /* Handle a 5 bit immediate at 31. */
- case 'V':
- get_expression (s);
- low_sign_unext (evaluate_absolute (the_insn.exp,
- the_insn.field_selector),
- 5, &im5);
- opcode |= im5;
- s = expr_end;
- continue;
-
- /* Handle an unsigned 5 bit immediate at 31. */
- case 'r':
- get_expression (s);
- im5 = evaluate_absolute (the_insn.exp, the_insn.field_selector);
- if (im5 > 31)
+ /* Handle a system control completer. */
+ case 'Z':
+ if (*s == ',' && (*(s + 1) == 'm' || *(s + 1) == 'M'))
{
- as_bad ("Operand out of range. Was: %d. Should be [0..31].",
- im5);
- im5 = im5 & 0x1f;
+ flag = 1;
+ s += 2;
}
- opcode |= im5;
- s = expr_end;
- continue;
+ else
+ flag = 0;
- /* Handle an unsigned 5 bit immediate at 15. */
- case 'R':
- get_expression (s);
- im5 = evaluate_absolute (the_insn.exp, the_insn.field_selector);
- if (im5 > 31)
- {
- as_bad ("Operand out of range. Was: %d. Should be [0..31].",
- im5);
- im5 = im5 & 0x1f;
- }
- opcode |= im5 << 16;
- s = expr_end;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, flag, 5);
+
+ /* Handle a nullification completer for branch instructions. */
+ case 'n':
+ nullif = pa_parse_nullif (&s);
+ INSERT_FIELD_AND_CONTINUE (opcode, nullif, 1);
/* Handle a 11 bit immediate at 31. */
case 'i':
the_insn.field_selector = pa_chk_field_selector (&s);
get_expression (s);
+ s = expr_end;
if (the_insn.exp.X_op == O_constant)
{
- low_sign_unext (evaluate_absolute (the_insn.exp,
- the_insn.field_selector),
- 11, &im11);
- opcode |= im11;
+ num = evaluate_absolute (&the_insn);
+ CHECK_FIELD (num, 1023, -1024, 0);
+ low_sign_unext (num, 11, &num);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
}
else
{
else
the_insn.reloc = R_HPPA;
the_insn.format = 11;
+ continue;
}
- s = expr_end;
- continue;
/* Handle a 14 bit immediate at 31. */
case 'j':
the_insn.field_selector = pa_chk_field_selector (&s);
get_expression (s);
+ s = expr_end;
if (the_insn.exp.X_op == O_constant)
{
- low_sign_unext (evaluate_absolute (the_insn.exp,
- the_insn.field_selector),
- 14, &im14);
- if (the_insn.field_selector == e_rsel)
- opcode |= (im14 & 0xfff);
- else
- opcode |= im14;
+ num = evaluate_absolute (&the_insn);
+ CHECK_FIELD (num, 8191, -8192, 0);
+ low_sign_unext (num, 14, &num);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
}
else
{
else
the_insn.reloc = R_HPPA;
the_insn.format = 14;
+ continue;
}
- s = expr_end;
- continue;
/* Handle a 21 bit immediate at 31. */
case 'k':
the_insn.field_selector = pa_chk_field_selector (&s);
get_expression (s);
+ s = expr_end;
if (the_insn.exp.X_op == O_constant)
{
- dis_assemble_21 (evaluate_absolute (the_insn.exp,
- the_insn.field_selector),
- &im21);
- opcode |= im21;
+ num = evaluate_absolute (&the_insn);
+ CHECK_FIELD (num >> 11, 1048575, -1048576, 0);
+ dis_assemble_21 (num, &num);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
}
else
{
else
the_insn.reloc = R_HPPA;
the_insn.format = 21;
+ continue;
}
- s = expr_end;
- continue;
-
- /* Handle a nullification completer for branch instructions. */
- case 'n':
- nullif = pa_parse_nullif (&s);
- opcode |= nullif << 1;
- continue;
/* Handle a 12 bit branch displacement. */
case 'w':
the_insn.field_selector = pa_chk_field_selector (&s);
get_expression (s);
+ s = expr_end;
the_insn.pcrel = 1;
- if (!strcmp (S_GET_NAME (the_insn.exp.X_add_symbol), "L0\001"))
+ if (!strcmp (S_GET_NAME (the_insn.exp.X_add_symbol), "L$0\001"))
{
unsigned int w1, w, result;
- sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 12,
- &result);
+ num = evaluate_absolute (&the_insn);
+ if (num % 4)
+ {
+ as_bad ("Branch to unaligned address");
+ break;
+ }
+ CHECK_FIELD (num, 8191, -8192, 0);
+ sign_unext ((num - 8) >> 2, 12, &result);
dis_assemble_12 (result, &w1, &w);
- opcode |= ((w1 << 2) | w);
+ INSERT_FIELD_AND_CONTINUE (opcode, ((w1 << 2) | w), 0);
}
else
{
the_insn.format = 12;
the_insn.arg_reloc = last_call_desc.arg_reloc;
bzero (&last_call_desc, sizeof (struct call_desc));
+ s = expr_end;
+ continue;
}
- s = expr_end;
- continue;
/* Handle a 17 bit branch displacement. */
case 'W':
the_insn.field_selector = pa_chk_field_selector (&s);
get_expression (s);
+ s = expr_end;
the_insn.pcrel = 1;
- if (the_insn.exp.X_add_symbol)
+ if (!the_insn.exp.X_add_symbol
+ || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
+ "L$0\001"))
{
- if (!strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
- "L0\001"))
- {
- unsigned int w2, w1, w, result;
+ unsigned int w2, w1, w, result;
- sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 17,
- &result);
- dis_assemble_17 (result, &w1, &w2, &w);
- opcode |= ((w2 << 2) | (w1 << 16) | w);
- }
- else
+ num = evaluate_absolute (&the_insn);
+ if (num % 4)
{
- if (is_complex (the_insn.exp))
- the_insn.reloc = R_HPPA_COMPLEX_PCREL_CALL;
- else
- the_insn.reloc = R_HPPA_PCREL_CALL;
- the_insn.format = 17;
- the_insn.arg_reloc = last_call_desc.arg_reloc;
- bzero (&last_call_desc, sizeof (struct call_desc));
+ as_bad ("Branch to unaligned address");
+ break;
}
+ CHECK_FIELD (num, 262143, -262144, 0);
+
+ if (the_insn.exp.X_add_symbol)
+ num -= 8;
+
+ sign_unext (num >> 2, 17, &result);
+ dis_assemble_17 (result, &w1, &w2, &w);
+ INSERT_FIELD_AND_CONTINUE (opcode,
+ ((w2 << 2) | (w1 << 16) | w), 0);
}
else
{
- unsigned int w2, w1, w, result;
-
- sign_unext (the_insn.exp.X_add_number >> 2, 17, &result);
- dis_assemble_17 (result, &w1, &w2, &w);
- opcode |= ((w2 << 2) | (w1 << 16) | w);
+ if (is_complex (the_insn.exp))
+ the_insn.reloc = R_HPPA_COMPLEX_PCREL_CALL;
+ else
+ the_insn.reloc = R_HPPA_PCREL_CALL;
+ the_insn.format = 17;
+ the_insn.arg_reloc = last_call_desc.arg_reloc;
+ bzero (&last_call_desc, sizeof (struct call_desc));
+ continue;
}
- s = expr_end;
- continue;
/* Handle an absolute 17 bit branch target. */
case 'z':
the_insn.field_selector = pa_chk_field_selector (&s);
get_expression (s);
+ s = expr_end;
the_insn.pcrel = 0;
- if (the_insn.exp.X_add_symbol)
+ if (!the_insn.exp.X_add_symbol
+ || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
+ "L$0\001"))
{
- if (!strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
- "L0\001"))
- {
- unsigned int w2, w1, w, result;
+ unsigned int w2, w1, w, result;
- sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 17,
- &result);
- dis_assemble_17 (result, &w1, &w2, &w);
- opcode |= ((w2 << 2) | (w1 << 16) | w);
- }
- else
+ num = evaluate_absolute (&the_insn);
+ if (num % 4)
{
- if (is_complex (the_insn.exp))
- the_insn.reloc = R_HPPA_COMPLEX_ABS_CALL;
- else
- the_insn.reloc = R_HPPA_ABS_CALL;
- the_insn.format = 17;
+ as_bad ("Branch to unaligned address");
+ break;
}
+ CHECK_FIELD (num, 262143, -262144, 0);
+
+ if (the_insn.exp.X_add_symbol)
+ num -= 8;
+
+ sign_unext (num >> 2, 17, &result);
+ dis_assemble_17 (result, &w1, &w2, &w);
+ INSERT_FIELD_AND_CONTINUE (opcode,
+ ((w2 << 2) | (w1 << 16) | w), 0);
}
else
{
- unsigned int w2, w1, w, result;
-
- result = evaluate_absolute (the_insn.exp,
- the_insn.field_selector);
- sign_unext (result >> 2, 17, &result);
- dis_assemble_17 (result, &w1, &w2, &w);
- opcode |= ((w2 << 2) | (w1 << 16) | w);
+ if (is_complex (the_insn.exp))
+ the_insn.reloc = R_HPPA_COMPLEX_ABS_CALL;
+ else
+ the_insn.reloc = R_HPPA_ABS_CALL;
+ the_insn.format = 17;
+ continue;
}
- s = expr_end;
- continue;
/* Handle a 5 bit shift count at 26. */
case 'p':
- get_expression (s);
- if (the_insn.exp.X_op == O_constant)
- opcode |= (((31 - the_insn.exp.X_add_number) & 0x1f) << 5);
+ num = pa_get_absolute_expression (&the_insn, &s);
s = expr_end;
- continue;
+ CHECK_FIELD (num, 31, 0, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, 31 - num, 5);
/* Handle a 5 bit bit position at 26. */
case 'P':
- get_expression (s);
- if (the_insn.exp.X_op == O_constant)
- opcode |= (the_insn.exp.X_add_number & 0x1f) << 5;
+ num = pa_get_absolute_expression (&the_insn, &s);
s = expr_end;
- continue;
+ CHECK_FIELD (num, 31, 0, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 5);
/* Handle a 5 bit immediate at 10. */
case 'Q':
- get_expression (s);
- im5 = evaluate_absolute (the_insn.exp, the_insn.field_selector);
- if (im5 > 31)
- {
- as_bad ("Operand out of range. Was: %d. Should be [0..31].",
- im5);
- im5 = im5 & 0x1f;
- }
- opcode |= im5 << 21;
+ num = pa_get_absolute_expression (&the_insn, &s);
s = expr_end;
- continue;
+ CHECK_FIELD (num, 31, 0, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
/* Handle a 13 bit immediate at 18. */
case 'A':
- pa_get_absolute_expression (s);
- if (the_insn.exp.X_op == O_constant)
- opcode |= (the_insn.exp.X_add_number & 0x1fff) << 13;
+ num = pa_get_absolute_expression (&the_insn, &s);
s = expr_end;
- continue;
-
- /* Handle a system control completer. */
- case 'Z':
- if (*s == ',' && (*(s + 1) == 'm' || *(s + 1) == 'M'))
- {
- m = 1;
- s += 2;
- }
- else
- m = 0;
-
- opcode |= m << 5;
- while (*s == ' ' || *s == '\t')
- s++;
- continue;
+ CHECK_FIELD (num, 4095, -4096, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
/* Handle a 26 bit immediate at 31. */
case 'D':
- the_insn.field_selector = pa_chk_field_selector (&s);
- get_expression (s);
- if (the_insn.exp.X_op == O_constant)
- {
- opcode |= ((evaluate_absolute (the_insn.exp,
- the_insn.field_selector)
- & 0x1ffffff) << 1);
- }
- else
- as_bad ("Invalid DIAG operand");
+ num = pa_get_absolute_expression (&the_insn, &s);
s = expr_end;
- continue;
+ CHECK_FIELD (num, 671108864, 0, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 1);
/* Handle a 3 bit SFU identifier at 25. */
case 'f':
- sfu = pa_parse_number (&s, 0);
- if ((sfu > 7) || (sfu < 0))
- as_bad ("Invalid SFU identifier: %02x", sfu);
- opcode |= (sfu & 7) << 6;
- continue;
+ num = pa_get_absolute_expression (&the_insn, &s);
+ s = expr_end;
+ CHECK_FIELD (num, 7, 0, 0);
+ INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
/* We don't support any of these. FIXME. */
case 'O':
/* Handle a source FP operand format completer. */
case 'F':
flag = pa_parse_fp_format (&s);
- opcode |= (int) flag << 11;
the_insn.fpof1 = flag;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
/* Handle a destination FP operand format completer. */
case 'G':
-
/* pa_parse_format needs the ',' prefix. */
s--;
flag = pa_parse_fp_format (&s);
- opcode |= (int) flag << 13;
the_insn.fpof2 = flag;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, flag, 13);
/* Handle FP compare conditions. */
case 'M':
cond = pa_parse_fp_cmp_cond (&s);
- opcode |= cond;
- continue;
+ INSERT_FIELD_AND_CONTINUE (opcode, cond, 0);
/* Handle L/R register halves like 't'. */
case 'v':
struct pa_89_fp_reg_struct result;
pa_parse_number (&s, &result);
- if (result.number_part < 32 && result.number_part >= 0)
- {
- opcode |= (result.number_part & 0x1f);
+ CHECK_FIELD (result.number_part, 31, 0, 0);
+ opcode |= result.number_part;
- /* 0x30 opcodes are FP arithmetic operation opcodes
- and need to be turned into 0x38 opcodes. This
- is not necessary for loads/stores. */
- if (need_89_opcode (&the_insn, &result))
- {
- if ((opcode & 0xfc000000) == 0x30000000)
- {
- opcode |= (result.l_r_select & 1) << 6;
- opcode |= 1 << 27;
- }
- else
- {
- opcode |= (result.l_r_select & 1) << 6;
- }
- }
- continue;
- }
+ /* 0x30 opcodes are FP arithmetic operation opcodes
+ and need to be turned into 0x38 opcodes. This
+ is not necessary for loads/stores. */
+ if (need_89_opcode (&the_insn, &result)
+ && ((opcode & 0xfc000000) == 0x30000000))
+ opcode |= 1 << 27;
+
+ INSERT_FIELD_AND_CONTINUE (opcode, result.l_r_select & 1, 6);
}
- break;
/* Handle L/R register halves like 'b'. */
case 'E':
struct pa_89_fp_reg_struct result;
pa_parse_number (&s, &result);
- if (result.number_part < 32 && result.number_part >= 0)
+ CHECK_FIELD (result.number_part, 31, 0, 0);
+ opcode |= result.number_part << 21;
+ if (need_89_opcode (&the_insn, &result))
{
- opcode |= (result.number_part & 0x1f) << 21;
- if (need_89_opcode (&the_insn, &result))
- {
- opcode |= (result.l_r_select & 1) << 7;
- opcode |= 1 << 27;
- }
- continue;
+ opcode |= (result.l_r_select & 1) << 7;
+ opcode |= 1 << 27;
}
+ continue;
}
- break;
/* Handle L/R register halves like 'x'. */
case 'X':
struct pa_89_fp_reg_struct result;
pa_parse_number (&s, &result);
- if (result.number_part < 32 && result.number_part >= 0)
+ CHECK_FIELD (result.number_part, 31, 0, 0);
+ opcode |= (result.number_part & 0x1f) << 16;
+ if (need_89_opcode (&the_insn, &result))
{
- opcode |= (result.number_part & 0x1f) << 16;
- if (need_89_opcode (&the_insn, &result))
- {
- opcode |= (result.l_r_select & 1) << 12;
- opcode |= 1 << 27;
- }
- continue;
+ opcode |= (result.l_r_select & 1) << 12;
+ opcode |= 1 << 27;
}
+ continue;
}
- break;
/* Handle a 5 bit register field at 10. */
case '4':
{
struct pa_89_fp_reg_struct result;
- int status;
-
- status = pa_parse_number (&s, &result);
- if (result.number_part < 32 && result.number_part >= 0)
+
+ pa_parse_number (&s, &result);
+ CHECK_FIELD (result.number_part, 31, 0, 0);
+ if (the_insn.fpof1 == SGL)
{
- if (the_insn.fpof1 == SGL)
- {
- result.number_part &= 0xF;
- result.number_part |= (result.l_r_select & 1) << 4;
- }
- opcode |= result.number_part << 21;
- continue;
+ result.number_part &= 0xF;
+ result.number_part |= (result.l_r_select & 1) << 4;
}
+ INSERT_FIELD_AND_CONTINUE (opcode, result.number_part, 21);
}
- break;
/* Handle a 5 bit register field at 15. */
case '6':
{
struct pa_89_fp_reg_struct result;
- int status;
- status = pa_parse_number (&s, &result);
- if (result.number_part < 32 && result.number_part >= 0)
+ pa_parse_number (&s, &result);
+ CHECK_FIELD (result.number_part, 31, 0, 0);
+ if (the_insn.fpof1 == SGL)
{
- if (the_insn.fpof1 == SGL)
- {
- result.number_part &= 0xF;
- result.number_part |= (result.l_r_select & 1) << 4;
- }
- opcode |= result.number_part << 16;
- continue;
+ result.number_part &= 0xF;
+ result.number_part |= (result.l_r_select & 1) << 4;
}
+ INSERT_FIELD_AND_CONTINUE (opcode, result.number_part, 16);
}
- break;
/* Handle a 5 bit register field at 31. */
case '7':
{
struct pa_89_fp_reg_struct result;
- int status;
- status = pa_parse_number (&s, &result);
- if (result.number_part < 32 && result.number_part >= 0)
+ pa_parse_number (&s, &result);
+ CHECK_FIELD (result.number_part, 31, 0, 0);
+ if (the_insn.fpof1 == SGL)
{
- if (the_insn.fpof1 == SGL)
- {
- result.number_part &= 0xF;
- result.number_part |= (result.l_r_select & 1) << 4;
- }
- opcode |= result.number_part;
- continue;
+ result.number_part &= 0xF;
+ result.number_part |= (result.l_r_select & 1) << 4;
}
+ INSERT_FIELD_AND_CONTINUE (opcode, result.number_part, 0);
}
- break;
/* Handle a 5 bit register field at 20. */
case '8':
{
struct pa_89_fp_reg_struct result;
- int status;
- status = pa_parse_number (&s, &result);
- if (result.number_part < 32 && result.number_part >= 0)
+ pa_parse_number (&s, &result);
+ CHECK_FIELD (result.number_part, 31, 0, 0);
+ if (the_insn.fpof1 == SGL)
{
- if (the_insn.fpof1 == SGL)
- {
- result.number_part &= 0xF;
- result.number_part |= (result.l_r_select & 1) << 4;
- }
- opcode |= result.number_part << 11;
- continue;
+ result.number_part &= 0xF;
+ result.number_part |= (result.l_r_select & 1) << 4;
}
+ INSERT_FIELD_AND_CONTINUE (opcode, result.number_part, 11);
}
- break;
/* Handle a 5 bit register field at 25. */
case '9':
{
struct pa_89_fp_reg_struct result;
- int status;
- status = pa_parse_number (&s, &result);
- if (result.number_part < 32 && result.number_part >= 0)
+ pa_parse_number (&s, &result);
+ CHECK_FIELD (result.number_part, 31, 0, 0);
+ if (the_insn.fpof1 == SGL)
{
- if (the_insn.fpof1 == SGL)
- {
- result.number_part &= 0xF;
- result.number_part |= (result.l_r_select & 1) << 4;
- }
- opcode |= result.number_part << 6;
- continue;
+ result.number_part &= 0xF;
+ result.number_part |= (result.l_r_select & 1) << 4;
}
+ INSERT_FIELD_AND_CONTINUE (opcode, result.number_part, 6);
}
- break;
/* Handle a floating point operand format at 26.
Only allows single and double precision. */
}
the_insn.opcode = opcode;
- return;
}
/* Turn a string in input_line_pointer into a floating point constant of type
valueT val;
int n;
{
-
- switch (n)
- {
- case 4:
- *buf++ = val >> 24;
- *buf++ = val >> 16;
- case 2:
- *buf++ = val >> 8;
- case 1:
- *buf = val;
- break;
- default:
- abort ();
- }
- return;
+ number_to_chars_bigendian (buf, val, n);
}
/* Translate internal representation of relocation info to BFD target
{
if (unwind_reloc_entryP == NULL)
{
- reloc = (arelent *) bfd_alloc_by_size_t (stdoutput,
+ reloc = (arelent *) bfd_alloc_by_size_t (stdoutput,
sizeof (arelent));
assert (reloc != 0);
unwind_reloc_entryP = reloc;
relocation should be either 0 (no static link) or 2
(static link required).
- FIXME: assume that fx_addnumber contains this
- information */
- reloc->addend = fixp->fx_addnumber;
+ FIXME: We always assume no static link! */
+ reloc->addend = 0;
break;
case R_HPPA_ABS_CALL_11:
}
#else /* OBJ_SOM */
- /* Preliminary relocation handling for SOM. Needs to handle
- COMPLEX relocations (yes, I've seen them occur) and it will
- need to handle R_ENTRY/R_EXIT relocations in the very near future
- (for generating unwinds). */
- switch (fixp->fx_r_type)
+ /* Walk over reach relocation returned by the BFD backend. */
+ for (i = 0; i < n_relocs; i++)
{
- case R_HPPA_COMPLEX:
- case R_HPPA_COMPLEX_PCREL_CALL:
- case R_HPPA_COMPLEX_ABS_CALL:
- abort();
- break;
- default:
- assert (n_relocs == 1);
-
- code = *codes[0];
-
- reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
- reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
- reloc->address = fixp->fx_frag->fr_address + fixp->fx_where ;
- reloc->addend = 0;
+ code = *codes[i];
+
+ relocs[i]->sym_ptr_ptr = &fixp->fx_addsy->bsym;
+ relocs[i]->howto = bfd_reloc_type_lookup (stdoutput, code);
+ relocs[i]->address = fixp->fx_frag->fr_address + fixp->fx_where;
switch (code)
{
case R_PCREL_CALL:
case R_ABS_CALL:
- reloc->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc, 0);
+ relocs[i]->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc, 0);
break;
+
+ case R_DATA_PLABEL:
+ case R_CODE_PLABEL:
+ /* For plabel relocations, the addend of the
+ relocation should be either 0 (no static link) or 2
+ (static link required).
+
+ FIXME: We always assume no static link! */
+ relocs[i]->addend = 0;
+ break;
+
+ case R_N_MODE:
+ case R_S_MODE:
+ case R_D_MODE:
+ case R_R_MODE:
+ case R_EXIT:
+ case R_FSEL:
+ case R_LSEL:
+ case R_RSEL:
+ /* There is no symbol or addend associated with these fixups. */
+ relocs[i]->sym_ptr_ptr = dummy_symbol;
+ relocs[i]->addend = 0;
+ break;
+
default:
- reloc->addend = fixp->fx_addnumber;
+ relocs[i]->addend = fixp->fx_addnumber;
break;
}
- break;
}
#endif
int align2 = (1 << align) - 1;
return (size + align2) & ~align2;
-
}
/* Create a short jump from FROM_ADDR to TO_ADDR. Not used on the PA. */
return size;
}
-/* Parse machine dependent options. There are none on the PA. */
+/* Parse machine dependent options. There are none on the PA. */
int
md_parse_option (argP, cntP, vecP)
char **argP;
{
}
-/* Helper function for md_apply_fix. Actually determine if the fix
- can be applied, and if so, apply it.
+/* Apply a fixup to an instruction. */
- If a fix is applied, then set fx_addsy to NULL which indicates
- the fix was applied and need not be emitted into the object file. */
-
-static void
-md_apply_fix_1 (fixP, val)
+int
+md_apply_fix (fixP, valp)
fixS *fixP;
- long val;
+ valueT *valp;
{
char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
struct hppa_fix_struct *hppa_fixP = fixP->tc_fix_data;
long new_val, result;
unsigned int w1, w2, w;
+ valueT val = *valp;
/* SOM uses R_HPPA_ENTRY and R_HPPA_EXIT relocations which can
- never be "applied". They must always be emitted. */
+ never be "applied" (they are just markers). */
#ifdef OBJ_SOM
if (fixP->fx_r_type == R_HPPA_ENTRY
|| fixP->fx_r_type == R_HPPA_EXIT)
- return;
+ return 1;
#endif
/* There should have been an HPPA specific fixup associated
unsigned long buf_wd = bfd_get_32 (stdoutput, buf);
unsigned char fmt = bfd_hppa_insn2fmt (buf_wd);
- /* Sanity check the fixup type. */
- /* Is this really necessary? */
if (fixP->fx_r_type == R_HPPA_NONE)
fmt = 0;
/* Remember this value for emit_reloc. FIXME, is this braindamage
- documented anywhere!?! */
+ documented anywhere!?! */
fixP->fx_addnumber = val;
/* Check if this is an undefined symbol. No relocation can
if ((fixP->fx_addsy && fixP->fx_addsy->bsym->section == &bfd_und_section)
|| (fixP->fx_subsy
&& fixP->fx_subsy->bsym->section == &bfd_und_section))
- return;
+ return 1;
+
+ /* PLABEL field selectors should not be passed to hppa_field_adjust. */
+ if (fmt != 0 && hppa_fixP->fx_r_field != R_HPPA_PSEL
+ && hppa_fixP->fx_r_field != R_HPPA_LPSEL
+ && hppa_fixP->fx_r_field != R_HPPA_RPSEL
+ && hppa_fixP->fx_r_field != R_HPPA_TSEL
+ && hppa_fixP->fx_r_field != R_HPPA_LTSEL
+ && hppa_fixP->fx_r_field != R_HPPA_RTSEL)
+ new_val = hppa_field_adjust (val, 0, hppa_fixP->fx_r_field);
+ else
+ new_val = 0;
switch (fmt)
{
/* Handle all opcodes with the 'j' operand type. */
case 14:
- new_val = hppa_field_adjust (val, 0, hppa_fixP->fx_r_field);
+ CHECK_FIELD (new_val, 8191, -8192, 0);
/* Mask off 14 bits to be changed. */
bfd_put_32 (stdoutput,
/* Handle all opcodes with the 'k' operand type. */
case 21:
- new_val = hppa_field_adjust (val, 0, hppa_fixP->fx_r_field);
+ CHECK_FIELD (new_val, 2097152, 0, 0);
/* Mask off 21 bits to be changed. */
bfd_put_32 (stdoutput,
/* Handle all the opcodes with the 'i' operand type. */
case 11:
- new_val = hppa_field_adjust (val, 0, hppa_fixP->fx_r_field);
+ CHECK_FIELD (new_val, 1023, -1023, 0);
/* Mask off 11 bits to be changed. */
bfd_put_32 (stdoutput,
/* Handle all the opcodes with the 'w' operand type. */
case 12:
- new_val = hppa_field_adjust (val, 0, hppa_fixP->fx_r_field);
+ CHECK_FIELD (new_val, 8191, -8192, 0)
/* Mask off 11 bits to be changed. */
- sign_unext ((new_val - 8) >> 2, 12, &result);
+ sign_unext ((new_val - 8) >> 2, 12, &result);
bfd_put_32 (stdoutput,
bfd_get_32 (stdoutput, buf) & 0xffffe002,
buf);
dis_assemble_12 (result, &w1, &w);
result = ((w1 << 2) | w);
- fixP->fx_addsy = NULL;
break;
-#define too_far(VAL, NUM_BITS) \
- (((int)(VAL) > (1 << (NUM_BITS)) - 1) || ((int)(VAL) < (-1 << (NUM_BITS))))
+ /* Handle some of the opcodes with the 'W' operand type. */
+ case 17:
#define stub_needed(CALLER, CALLEE) \
((CALLEE) && (CALLER) && ((CALLEE) != (CALLER)))
+ /* It is necessary to force PC-relative calls/jumps to have a
+ relocation entry if they're going to need either a argument
+ relocation or long call stub. FIXME. Can't we need the same
+ for absolute calls? */
+ if (fixP->fx_addsy
+ && (stub_needed (((obj_symbol_type *)
+ fixP->fx_addsy->bsym)->tc_data.hppa_arg_reloc,
+ hppa_fixP->fx_arg_reloc)))
+ return 1;
+#undef stub_needed
- /* Handle some of the opcodes with the 'W' operand type. */
- case 17:
- /* If a long-call stub or argument relocation stub is
- needed, then we can not apply this relocation, instead
- the linker must handle it. */
- if (too_far (val, 18)
- || stub_needed (((obj_symbol_type *)
- fixP->fx_addsy->bsym)->tc_data.hppa_arg_reloc,
- hppa_fixP->fx_arg_reloc))
- return;
-
- /* No stubs were needed, we can perform this relocation. */
- new_val = hppa_field_adjust (val, 0, hppa_fixP->fx_r_field);
+ CHECK_FIELD (new_val, 262143, -262144, 0);
/* Mask off 17 bits to be changed. */
bfd_put_32 (stdoutput,
sign_unext ((new_val - 8) >> 2, 17, &result);
dis_assemble_17 (result, &w1, &w2, &w);
result = ((w2 << 2) | (w1 << 16) | w);
- fixP->fx_addsy = NULL;
break;
-#undef too_far
-#undef stub_needed
-
case 32:
#ifdef OBJ_ELF
/* These are ELF specific relocations. ELF unfortunately
{
result = 0;
fixP->fx_addnumber = fixP->fx_offset;
- bfd_put_32 (stdoutput, 0, buf);
- return;
+ /* If we have a real relocation, then we want zero to
+ be stored in the object file. If no relocation is going
+ to be emitted, then we need to store new_val into the
+ object file. */
+ if (fixP->fx_addsy)
+ bfd_put_32 (stdoutput, 0, buf);
+ else
+ bfd_put_32 (stdoutput, new_val, buf);
+ return 1;
}
break;
case 0:
- return;
+ return 1;
default:
- as_bad ("bad relocation type/fmt: 0x%02x/0x%02x",
- fixP->fx_r_type, fmt);
- return;
+ as_bad ("Unknown relocation encountered in md_apply_fix.");
+ return 1;
}
/* Insert the relocation. */
- buf[0] |= (result & 0xff000000) >> 24;
- buf[1] |= (result & 0x00ff0000) >> 16;
- buf[2] |= (result & 0x0000ff00) >> 8;
- buf[3] |= result & 0x000000ff;
+ bfd_put_32 (stdoutput, bfd_get_32 (stdoutput, buf) | result, buf);
+ return 1;
}
else
- printf ("no hppa_fixup entry for this fixup (fixP = 0x%x, type = 0x%x)\n",
- (unsigned int) fixP, fixP->fx_r_type);
-}
-
-/* Apply a fix into a frag's data (if possible). */
-
-int
-md_apply_fix (fixP, valp)
- fixS *fixP;
- valueT *valp;
-{
- md_apply_fix_1 (fixP, (long) *valp);
- return 1;
+ {
+ printf ("no hppa_fixup entry for this fixup (fixP = 0x%x, type = 0x%x)\n",
+ (unsigned int) fixP, fixP->fx_r_type);
+ return 0;
+ }
}
/* Exactly what point is a PC-relative offset relative TO?
char *name;
{
int middle, low, high;
+ int cmp;
low = 0;
high = REG_NAME_CNT - 1;
do
{
middle = (low + high) / 2;
- if (strcasecmp (name, pre_defined_registers[middle].name) < 0)
+ cmp = strcasecmp (name, pre_defined_registers[middle].name);
+ if (cmp < 0)
high = middle - 1;
- else
+ else if (cmp > 0)
low = middle + 1;
+ else
+ return pre_defined_registers[middle].value;
}
- while (!((strcasecmp (name, pre_defined_registers[middle].name) == 0) ||
- (low > high)));
+ while (low <= high);
- if (strcasecmp (name, pre_defined_registers[middle].name) == 0)
- return (pre_defined_registers[middle].value);
- else
- return (-1);
+ return -1;
}
/* Parse a condition for a fcmp instruction. Return the numerical
code associated with the condition. */
-
+
static int
pa_parse_fp_cmp_cond (s)
char **s;
/* Parse an FP operand format completer returning the completer
type. */
-
+
static fp_operand_format
pa_parse_fp_format (s)
char **s;
as_bad ("Invalid FP Operand Format: %3s", *s);
}
}
- while (**s == ' ' || **s == '\t' || **s == 0)
- *s = *s + 1;
return format;
}
pa_chk_field_selector (str)
char **str;
{
- int selector;
- const struct selector_entry *tablep;
-
- selector = e_fsel;
+ int middle, low, high;
+ int cmp;
+ char name[3];
/* Read past any whitespace. */
+ /* FIXME: should we read past newlines and formfeeds??? */
while (**str == ' ' || **str == '\t' || **str == '\n' || **str == '\f')
*str = *str + 1;
- /* Yuk. Looks like a linear search through the table. With the
- frequence of some selectors it might make sense to sort the
- table by usage. */
- for (tablep = selector_table; tablep->prefix; tablep++)
+ if ((*str)[1] == '\'' || (*str)[1] == '%')
+ name[0] = tolower ((*str)[0]),
+ name[1] = 0;
+ else if ((*str)[2] == '\'' || (*str)[2] == '%')
+ name[0] = tolower ((*str)[0]),
+ name[1] = tolower ((*str)[1]),
+ name[2] = 0;
+ else
+ return e_fsel;
+
+ low = 0;
+ high = sizeof (selector_table) / sizeof (struct selector_entry) - 1;
+
+ do
{
- if (strncasecmp (tablep->prefix, *str, strlen (tablep->prefix)) == 0)
+ middle = (low + high) / 2;
+ cmp = strcmp (name, selector_table[middle].prefix);
+ if (cmp < 0)
+ high = middle - 1;
+ else if (cmp > 0)
+ low = middle + 1;
+ else
{
- *str += strlen (tablep->prefix);
- selector = tablep->field_selector;
- break;
+ *str += strlen (name) + 1;
+ return selector_table[middle].field_selector;
}
}
- return selector;
+ while (low <= high);
+
+ return e_fsel;
}
-/* Mark (via expr_end) the end of an expression (I think). FIXME. */
+/* Mark (via expr_end) the end of an expression (I think). FIXME. */
static int
get_expression (str)
|| seg == undefined_section
|| SEG_NORMAL (seg)))
{
- as_warn ("Bad segment in expression.");
+ as_warn ("Bad segment in expression.");
expr_end = input_line_pointer;
input_line_pointer = save_in;
return 1;
/* Mark (via expr_end) the end of an absolute expression. FIXME. */
static int
-pa_get_absolute_expression (str)
- char *str;
+pa_get_absolute_expression (insn, strp)
+ struct pa_it *insn;
+ char **strp;
{
char *save_in;
+ insn->field_selector = pa_chk_field_selector (strp);
save_in = input_line_pointer;
- input_line_pointer = str;
- expression (&the_insn.exp);
- if (the_insn.exp.X_op != O_constant)
+ input_line_pointer = *strp;
+ expression (&insn->exp);
+ if (insn->exp.X_op != O_constant)
{
- as_warn ("Bad segment (should be absolute).");
+ as_bad ("Bad segment (should be absolute).");
expr_end = input_line_pointer;
input_line_pointer = save_in;
- return 1;
+ return 0;
}
expr_end = input_line_pointer;
input_line_pointer = save_in;
- return 0;
+ return evaluate_absolute (insn);
}
/* Evaluate an absolute expression EXP which may be modified by
the selector FIELD_SELECTOR. Return the value of the expression. */
static int
-evaluate_absolute (exp, field_selector)
- expressionS exp;
- int field_selector;
+evaluate_absolute (insn)
+ struct pa_it *insn;
{
int value;
+ expressionS exp;
+ int field_selector = insn->field_selector;
+ exp = insn->exp;
value = exp.X_add_number;
switch (field_selector)
/* Add 0x800 and arithmetic shift right 11 bits. */
case e_ldsel:
value += 0x800;
-
-
value = (value & 0xfffff800) >> 11;
break;
value |= 0xfffff800;
break;
- /* This had better get fixed. It looks like we're quickly moving
- to LR/RR. FIXME. */
+#define RSEL_ROUND(c) (((c) + 0x1000) & ~0x1fff)
case e_rrsel:
+ value = (RSEL_ROUND (value) & 0x7ff) + (value - RSEL_ROUND (value));
+ break;
+
case e_lrsel:
- abort ();
+ value = (RSEL_ROUND (value) >> 11) & 0x1fffff;
+ break;
+#undef RSEL_ROUND
default:
BAD_CASE (field_selector);
}
*s = *s + 1;
}
- while (**s == ' ' || **s == '\t')
- *s = *s + 1;
return nullif;
}
}
**s = c;
}
- if (cmpltr >= 0)
- {
- while (**s == ' ' || **s == '\t')
- *s = *s + 1;
- }
/* Reset pointers if this was really a ,n for a branch instruction. */
if (cmpltr == 0 && *name == 'n' && isbranch)
}
**s = c;
}
- if (cmpltr >= 0)
- {
- while (**s == ' ' || **s == '\t')
- *s = *s + 1;
- }
/* Reset pointers if this was really a ,n for a branch instruction. */
if (cmpltr == 0 && *name == 'n' && isbranch)
}
**s = c;
}
- if (cmpltr >= 0)
- {
- while (**s == ' ' || **s == '\t')
- *s = *s + 1;
- }
/* Reset pointers if this was really a ,n for a branch instruction. */
if (cmpltr == 0 && *name == 'n' && isbranch)
{
cmpltr = 3;
}
- else if (strcmp (name, "uv") == 0)
+ else if (strcasecmp (name, "uv") == 0)
{
cmpltr = 4;
}
- else if (strcmp (name, "vnz") == 0)
+ else if (strcasecmp (name, "vnz") == 0)
{
cmpltr = 5;
}
}
**s = c;
}
- if (cmpltr >= 0)
- {
- while (**s == ' ' || **s == '\t')
- *s = *s + 1;
- }
/* Reset pointers if this was really a ,n for a branch instruction. */
if (cmpltr == 0 && *name == 'n' && isbranch)
/* Always fill with zeros, that's what the HP assembler does. */
temp_fill = 0;
- p = frag_var (rs_fill, (int) temp_size, (int) temp_size,
+ p = frag_var (rs_fill, (int) temp_size, (int) temp_size,
(relax_substateT) 0, (symbolS *) 0, 1, NULL);
bzero (p, temp_size);
pa_undefine_label ();
demand_empty_rest_of_line ();
- return;
}
/* Handle a .CALL pseudo-op. This involves storing away information
{
pa_call_args (&last_call_desc);
demand_empty_rest_of_line ();
- return;
}
/* Do the dirty work of building a call descriptor which describes
attributes in CALL_INFO. This is not needed for SOM as using
R_ENTRY and R_EXIT relocations allow the linker to handle building
of the unwind spaces. */
-
+
static void
pa_build_unwind_subspace (call_info)
struct call_info *call_info;
/* Get some space to hold relocation information for the unwind
descriptor. */
p = frag_more (4);
- call_info->start_offset_frag = frag_now;
- call_info->start_frag_where = p - frag_now->fr_literal;
/* Relocation info. for start offset of the function. */
fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
(expressionS *) NULL, 0, R_HPPA_UNWIND, e_fsel, 32, 0,
(char *) 0);
- /* We need to search for the first relocation involving the start_symbol of
- this call_info descriptor. */
- {
- fixS *fixP;
-
- call_info->start_fix = seg_info (now_seg)->fix_root;
- for (fixP = call_info->start_fix; fixP; fixP = fixP->fx_next)
- {
- if (fixP->fx_addsy == call_info->start_symbol
- || fixP->fx_subsy == call_info->start_symbol)
- {
- call_info->start_fix = fixP;
- break;
- }
- }
- }
-
p = frag_more (4);
- call_info->end_offset_frag = frag_now;
- call_info->end_frag_where = p - frag_now->fr_literal;
/* Relocation info. for end offset of the function. */
fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
(expressionS *) NULL, 0, R_HPPA_UNWIND, e_fsel, 32, 0,
(char *) 0);
- /* We need to search for the first relocation involving the end_symbol of
- this call_info descriptor. */
- {
- fixS *fixP;
-
- call_info->end_fix = seg_info (now_seg)->fix_root; /* the default */
- for (fixP = call_info->end_fix; fixP; fixP = fixP->fx_next)
- {
- if (fixP->fx_addsy == call_info->end_symbol
- || fixP->fx_subsy == call_info->end_symbol)
- {
- call_info->end_fix = fixP;
- break;
- }
- }
- }
-
/* Dump it. */
unwind = (char *) &call_info->ci_unwind;
for (i = 8; i < sizeof (struct unwind_table); i++)
temp = 0;
}
- /* callinfo is in bytes and unwind_desc is in 8 byte units. */
+ /* callinfo is in bytes and unwind_desc is in 8 byte units. */
last_call_info->ci_unwind.descriptor.frame_size = temp / 8;
}
temp = get_absolute_expression ();
if (temp != 3)
as_bad ("Value for ENTRY_SR must be 3\n");
- last_call_info->entry_sr = temp - 2;
}
/* Note whether or not this function performs any calls. */
else if ((strncasecmp (name, "calls", 5) == 0) ||
{
p = input_line_pointer;
*p = c;
- last_call_info->makes_calls = 1;
}
else if ((strncasecmp (name, "no_calls", 8) == 0))
{
p = input_line_pointer;
*p = c;
- last_call_info->makes_calls = 0;
}
/* Should RP be saved into the stack. */
else if ((strncasecmp (name, "save_rp", 7) == 0))
last_call_info->ci_unwind.descriptor.save_sp = 1;
}
/* Is this an unwindable procedure. If so mark it so
- in the unwind descriptor. */
+ in the unwind descriptor. */
else if ((strncasecmp (name, "no_unwind", 9) == 0))
{
p = input_line_pointer;
last_call_info->ci_unwind.descriptor.cannot_unwind = 1;
}
/* Is this an interrupt routine. If so mark it in the
- unwind descriptor. */
+ unwind descriptor. */
else if ((strncasecmp (name, "hpux_int", 7) == 0))
{
p = input_line_pointer;
}
demand_empty_rest_of_line ();
- return;
}
/* Switch into the code subspace. */
SPACE_DEFINED (sdchain) = 1;
subseg_set (text_section, SUBSEG_CODE);
demand_empty_rest_of_line ();
- return;
}
/* This is different than the standard GAS s_comm(). On HP9000/800 machines,
if (symbol)
{
/* It is incorrect to check S_IS_DEFINED at this point as
- the symbol will *always* be defined. FIXME. How to
- correctly determine when this label really as been
- defined before. */
+ the symbol will *always* be defined. FIXME. How to
+ correctly determine when this label really as been
+ defined before. */
if (S_GET_VALUE (symbol))
{
if (S_GET_VALUE (symbol) != size)
demand_empty_rest_of_line ();
}
-/* Process a .COPYRIGHT pseudo-op. */
-
-static void
-pa_copyright (unused)
- int unused;
-{
- char *name;
- char c;
-
- SKIP_WHITESPACE ();
- if (*input_line_pointer == '\"')
- {
- ++input_line_pointer;
- name = input_line_pointer;
- while ((c = next_char_of_string ()) >= 0)
- ;
- c = *input_line_pointer;
- *input_line_pointer = '\0';
- *(input_line_pointer - 1) = '\0';
- {
- /* FIXME. Not supported */
- abort ();
- }
- *input_line_pointer = c;
- }
- else
- {
- as_bad ("Expected \"-ed string");
- }
- pa_undefine_label ();
- demand_empty_rest_of_line ();
-}
-
/* Process a .END pseudo-op. */
static void
int unused;
{
demand_empty_rest_of_line ();
- return;
}
-/* Process a .ENTER pseudo-op. This is not supported. */
+/* Process a .ENTER pseudo-op. This is not supported. */
static void
pa_enter (unused)
int unused;
{
- abort();
- return;
+ abort ();
}
/* Process a .ENTRY pseudo-op. .ENTRY marks the beginning of the
{
if (!callinfo_found)
as_bad ("Missing .callinfo.");
-
- last_call_info->start_frag = frag_now;
}
demand_empty_rest_of_line ();
within_entry_exit = TRUE;
denote the entry and exit points. */
{
char *where = frag_more (0);
-
- fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
+
+ fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
last_call_info->start_symbol, (offsetT) 0, NULL,
0, R_HPPA_ENTRY, e_fsel, 0, 0,
- (char *)&last_call_info->ci_unwind.descriptor);
+ (char *) &last_call_info->ci_unwind.descriptor);
}
#endif
-
- return;
}
/* Handle a .EQU pseudo-op. */
pa_undefine_label ();
demand_empty_rest_of_line ();
- return;
}
/* Helper function. Does processing for the end of a function. This
where = frag_more (0);
#ifdef OBJ_ELF
- /* ELF does not have EXIT relocations. All we do is create a
- temporary symbol marking the end of the function. */
- {
- char *name = (char *) xmalloc (strlen ("L$\001end_") +
- strlen (S_GET_NAME (last_call_info->start_symbol)) + 1);
-
- if (name)
- {
- symbolS *symbolP;
-
- strcpy (name, "L$\001end_");
- strcat (name, S_GET_NAME (last_call_info->start_symbol));
-
- symbolP = symbol_find (name);
- if (symbolP)
- as_warn ("Symbol '%s' already defined.", name);
- else
- {
- /* symbol value should be the offset of the
- last instruction of the function */
- symbolP = symbol_new (name, now_seg,
- (valueT) (obstack_next_free (&frags)
- - frag_now->fr_literal - 4),
- frag_now);
-
- assert (symbolP);
- symbolP->bsym->flags = BSF_LOCAL;
- symbol_table_insert (symbolP);
- }
- if (symbolP)
- last_call_info->end_symbol = symbolP;
- else
- as_bad ("Symbol '%s' could not be created.", name);
-
- }
- else
- as_bad ("No memory for symbol name.");
- }
-
- /* Stuff away the location of the frag for the end of the function,
- and call pa_build_unwind_subspace to add an entry in the unwind
- table. */
- last_call_info->end_frag = frag_now;
+ /* Mark the end of the function, stuff away the location of the frag
+ for the end of the function, and finally call pa_build_unwind_subspace
+ to add an entry in the unwind table. */
+ hppa_elf_mark_end_of_function ();
pa_build_unwind_subspace (last_call_info);
#else
/* SOM defers building of unwind descriptors until the link phase.
last_call_info->start_symbol, (offsetT) 0,
NULL, 0, R_HPPA_EXIT, e_fsel, 0, 0, NULL);
#endif
-
- exit_processing_complete = TRUE;
}
/* Process a .EXIT pseudo-op. */
}
}
demand_empty_rest_of_line ();
- return;
}
/* Process a .EXPORT directive. This makes functions external
if (!is_end_of_statement ())
{
input_line_pointer++;
- pa_export_args (symbol);
+ pa_type_args (symbol, 1);
#ifdef OBJ_ELF
pa_build_symextn_section ();
#endif
}
demand_empty_rest_of_line ();
- return;
}
/* Helper function to process arguments to a .EXPORT pseudo-op. */
static void
-pa_export_args (symbolP)
+pa_type_args (symbolP, is_export)
symbolS *symbolP;
+ int is_export;
{
char *name, c, *p;
unsigned int temp, arg_reloc;
obj_symbol_type *symbol = (obj_symbol_type *) symbolP->bsym;
if (strncasecmp (input_line_pointer, "absolute", 8) == 0)
+
{
input_line_pointer += 8;
symbolP->bsym->flags &= ~BSF_FUNCTION;
else if (strncasecmp (input_line_pointer, "code", 4) == 0)
{
input_line_pointer += 4;
- symbolP->bsym->flags &= ~BSF_FUNCTION;
- type = SYMBOL_TYPE_CODE;
+ /* IMPORTing/EXPORTing CODE types for functions is meaningless for SOM,
+ instead one should be IMPORTing/EXPORTing ENTRY types.
+
+ Complain if one tries to EXPORT a CODE type since that's never
+ done. Both GCC and HP C still try to IMPORT CODE types, so
+ silently fix them to be ENTRY types. */
+ if (symbolP->bsym->flags & BSF_FUNCTION)
+ {
+ if (is_export)
+ as_tsktsk ("Using ENTRY rather than CODE in export directive for %s", symbolP->bsym->name);
+
+ symbolP->bsym->flags |= BSF_FUNCTION;
+ type = SYMBOL_TYPE_ENTRY;
+ }
+ else
+ {
+ symbolP->bsym->flags &= ~BSF_FUNCTION;
+ type = SYMBOL_TYPE_CODE;
+ }
}
else if (strncasecmp (input_line_pointer, "data", 4) == 0)
{
if (!is_end_of_statement ())
{
input_line_pointer++;
- pa_export_args (symbol);
+ pa_type_args (symbol, 0);
}
else
{
/* Sigh. To be compatable with the HP assembler and to help
- poorly written assembly code, we assign a type based on
- the the current segment. Note only BSF_FUNCTION really
- matters, we do not need to set the full SYMBOL_TYPE_* info here. */
+ poorly written assembly code, we assign a type based on
+ the the current segment. Note only BSF_FUNCTION really
+ matters, we do not need to set the full SYMBOL_TYPE_* info here. */
if (now_seg == text_section)
symbol->bsym->flags |= BSF_FUNCTION;
}
demand_empty_rest_of_line ();
- return;
}
/* Handle a .LABEL pseudo-op. */
ignore_rest_of_line ();
}
demand_empty_rest_of_line ();
- return;
}
/* Handle a .LEAVE pseudo-op. This is not supported yet. */
pa_leave (unused)
int unused;
{
- abort();
+ abort ();
}
/* Handle a .ORIGIN pseudo-op. */
{
s_org (0);
pa_undefine_label ();
- return;
}
/* Handle a .PARAM pseudo-op. This is much like a .EXPORT, except it
if (!is_end_of_statement ())
{
input_line_pointer++;
- pa_export_args (symbol);
+ pa_type_args (symbol, 0);
}
}
demand_empty_rest_of_line ();
- return;
}
/* Handle a .PROC pseudo-op. It is used to mark the beginning
/* Reset global variables for new procedure. */
callinfo_found = FALSE;
within_procedure = TRUE;
- exit_processing_complete = FALSE;
/* Create another call_info structure. */
call_info = (struct call_info *) xmalloc (sizeof (struct call_info));
call_info->ci_unwind.descriptor.cannot_unwind = 0;
call_info->ci_unwind.descriptor.region_desc = 1;
call_info->ci_unwind.descriptor.hpux_interrupt_marker = 0;
- call_info->entry_sr = ~0;
- call_info->makes_calls = 1;
/* If we got a .PROC pseudo-op, we know that the function is defined
locally. Make sure it gets into the symbol table. */
label_symbol->lss_label->bsym->flags |= BSF_FUNCTION;
}
else
- as_bad ("Missing function name for .PROC (corrupted label)");
+ as_bad ("Missing function name for .PROC (corrupted label chain)");
}
else
- as_bad ("Missing function name for .PROC");
+ last_call_info->start_symbol = NULL;
}
demand_empty_rest_of_line ();
- return;
}
/* Process the syntatical end of a procedure. Make sure all the
if (within_entry_exit)
as_bad ("Missing .EXIT for a .ENTRY");
- if (!exit_processing_complete)
- process_exit ();
+#ifdef OBJ_ELF
+ /* ELF needs to mark the end of each function so that it can compute
+ the size of the function (apparently its needed in the symbol table. */
+ hppa_elf_mark_end_of_function ();
+#endif
within_procedure = FALSE;
demand_empty_rest_of_line ();
- return;
}
/* Parse the parameters to a .SPACE directive; if CREATE_FLAG is nonzero,
loadable = TRUE;
defined = TRUE;
private = FALSE;
- if (strcasecmp (space_name, "$TEXT$") == 0)
+ if (strcmp (space_name, "$TEXT$") == 0)
{
seg = pa_def_spaces[0].segment;
sort = pa_def_spaces[0].sort;
}
- else if (strcasecmp (space_name, "$PRIVATE$") == 0)
+ else if (strcmp (space_name, "$PRIVATE$") == 0)
{
seg = pa_def_spaces[1].segment;
sort = pa_def_spaces[1].sort;
input_line_pointer++;
name = input_line_pointer;
c = get_symbol_end ();
- if ((strncasecmp (name, "SPNUM", 5) == 0))
+ if ((strncasecmp (name, "spnum", 5) == 0))
{
*input_line_pointer = c;
input_line_pointer++;
spnum = get_absolute_expression ();
}
- else if ((strncasecmp (name, "SORT", 4) == 0))
+ else if ((strncasecmp (name, "sort", 4) == 0))
{
*input_line_pointer = c;
input_line_pointer++;
sort = get_absolute_expression ();
}
- else if ((strncasecmp (name, "UNLOADABLE", 10) == 0))
+ else if ((strncasecmp (name, "unloadable", 10) == 0))
{
*input_line_pointer = c;
loadable = FALSE;
}
- else if ((strncasecmp (name, "NOTDEFINED", 10) == 0))
+ else if ((strncasecmp (name, "notdefined", 10) == 0))
{
*input_line_pointer = c;
defined = FALSE;
}
- else if ((strncasecmp (name, "PRIVATE", 7) == 0))
+ else if ((strncasecmp (name, "private", 7) == 0))
{
*input_line_pointer = c;
private = TRUE;
{
as_bad ("Invalid .SPACE argument");
*input_line_pointer = c;
- if (! is_end_of_statement ())
+ if (!is_end_of_statement ())
input_line_pointer++;
}
}
if (create_flag && seg == NULL)
seg = subseg_new (space_name, 0);
-
+
/* If create_flag is nonzero, then create the new space with
the attributes computed above. Else set the values in
an already existing space -- this can only happen for
{
space = is_defined_space (space_name);
SPACE_SPNUM (space) = spnum;
- SPACE_LOADABLE (space) = loadable & 1;
SPACE_DEFINED (space) = defined & 1;
SPACE_USER_DEFINED (space) = 1;
- SPACE_PRIVATE (space) = private & 1;
- SPACE_SORT (space) = sort & 0xff;
space->sd_seg = seg;
}
return space;
}
-/* Adjust the frag's alignment according to the alignment needs
- of the given subspace/subsegment. */
-
-static void
-pa_align_subseg (seg, subseg)
- asection *seg;
- subsegT subseg;
-{
- ssd_chain_struct *now_subspace;
- int alignment;
- int shift = 0;
-
- now_subspace = pa_subsegment_to_subspace (seg, subseg);
- if (now_subspace)
- {
- if (SUBSPACE_ALIGN (now_subspace) == 0)
- alignment = now_subspace->ssd_last_align;
- else if (now_subspace->ssd_last_align > SUBSPACE_ALIGN (now_subspace))
- alignment = now_subspace->ssd_last_align;
- else
- alignment = SUBSPACE_ALIGN (now_subspace);
-
- while ((1 << shift) < alignment)
- shift++;
- }
- else
- shift = bfd_get_section_alignment (stdoutput, seg);
-
- frag_align (shift, 0);
-}
-
/* Handle a .SPACE pseudo-op; this switches the current space to the
given space, creating the new space if necessary. */
/* Check for some of the predefined spaces. FIXME: most of the code
below is repeated several times, can we extract the common parts
and place them into a subroutine or something similar? */
- if (strncasecmp (input_line_pointer, "$text$", 6) == 0)
+ /* FIXME Is this (and the next IF stmt) really right?
+ What if INPUT_LINE_POINTER points to "$TEXT$FOO"? */
+ if (strncmp (input_line_pointer, "$TEXT$", 6) == 0)
{
input_line_pointer += 6;
sd_chain = is_defined_space ("$TEXT$");
sd_chain = pa_parse_space_stmt ("$TEXT$", 0);
current_space = sd_chain;
-
- /* No need to align if we are already there. */
- if (now_seg != text_section)
- pa_align_subseg (now_seg, now_subseg);
-
subseg_set (text_section, sd_chain->sd_last_subseg);
-
current_subspace
= pa_subsegment_to_subspace (text_section,
sd_chain->sd_last_subseg);
demand_empty_rest_of_line ();
return;
}
- if (strncasecmp (input_line_pointer, "$private$", 9) == 0)
+ if (strncmp (input_line_pointer, "$PRIVATE$", 9) == 0)
{
input_line_pointer += 9;
sd_chain = is_defined_space ("$PRIVATE$");
sd_chain = pa_parse_space_stmt ("$PRIVATE$", 0);
current_space = sd_chain;
-
- /* No need to align if we are already there. */
- if (now_seg != data_section)
- pa_align_subseg (now_seg, now_subseg);
-
subseg_set (data_section, sd_chain->sd_last_subseg);
current_subspace
= pa_subsegment_to_subspace (data_section,
asection *gdb_section
= bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME);
- /* No need to align if we are already there. */
- if (strcmp (segment_name (now_seg), GDB_DEBUG_SPACE_NAME) != 0)
- pa_align_subseg (now_seg, now_subseg);
-
subseg_set (gdb_section, sd_chain->sd_last_subseg);
current_subspace
= pa_subsegment_to_subspace (gdb_section,
{
current_space = sd_chain;
- if (now_seg != sd_chain->sd_seg)
- pa_align_subseg (now_seg, now_subseg);
subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
current_subspace
= pa_subsegment_to_subspace (sd_chain->sd_seg,
sd_chain = pa_parse_space_stmt (space_name, 1);
current_space = sd_chain;
- if (now_seg != sd_chain->sd_seg)
- pa_align_subseg (now_seg, now_subseg);
subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
sd_chain->sd_last_subseg);
demand_empty_rest_of_line ();
}
- return;
}
-/* Switch to a new space. (I think). FIXME. */
+/* Switch to a new space. (I think). FIXME. */
static void
pa_spnum (unused)
*input_line_pointer = c;
demand_empty_rest_of_line ();
- return;
}
/* If VALUE is an exact power of two between zero and 2^31, then
space = current_space;
ssd = is_defined_subspace (ss_name);
/* Allow user to override the builtin attributes of subspaces. But
- only allow the attributes to be changed once! */
+ only allow the attributes to be changed once! */
if (ssd && SUBSPACE_DEFINED (ssd))
{
subseg_set (ssd->ssd_seg, ssd->ssd_subseg);
{
name = input_line_pointer;
c = get_symbol_end ();
- if ((strncasecmp (name, "QUAD", 4) == 0))
+ if ((strncasecmp (name, "quad", 4) == 0))
{
*input_line_pointer = c;
input_line_pointer++;
quadrant = get_absolute_expression ();
}
- else if ((strncasecmp (name, "ALIGN", 5) == 0))
+ else if ((strncasecmp (name, "align", 5) == 0))
{
*input_line_pointer = c;
input_line_pointer++;
alignment = 1;
}
}
- else if ((strncasecmp (name, "ACCESS", 6) == 0))
+ else if ((strncasecmp (name, "access", 6) == 0))
{
*input_line_pointer = c;
input_line_pointer++;
access = get_absolute_expression ();
}
- else if ((strncasecmp (name, "SORT", 4) == 0))
+ else if ((strncasecmp (name, "sort", 4) == 0))
{
*input_line_pointer = c;
input_line_pointer++;
sort = get_absolute_expression ();
}
- else if ((strncasecmp (name, "CODE_ONLY", 9) == 0))
+ else if ((strncasecmp (name, "code_only", 9) == 0))
{
*input_line_pointer = c;
code_only = 1;
}
- else if ((strncasecmp (name, "UNLOADABLE", 10) == 0))
+ else if ((strncasecmp (name, "unloadable", 10) == 0))
{
*input_line_pointer = c;
loadable = 0;
}
- else if ((strncasecmp (name, "COMMON", 6) == 0))
+ else if ((strncasecmp (name, "common", 6) == 0))
{
*input_line_pointer = c;
common = 1;
}
- else if ((strncasecmp (name, "DUP_COMM", 8) == 0))
+ else if ((strncasecmp (name, "dup_comm", 8) == 0))
{
*input_line_pointer = c;
dup_common = 1;
}
- else if ((strncasecmp (name, "ZERO", 4) == 0))
+ else if ((strncasecmp (name, "zero", 4) == 0))
{
*input_line_pointer = c;
zero = 1;
}
- else if ((strncasecmp (name, "FIRST", 5) == 0))
+ else if ((strncasecmp (name, "first", 5) == 0))
as_bad ("FIRST not supported as a .SUBSPACE argument");
else
as_bad ("Invalid .SUBSPACE argument");
}
/* Compute a reasonable set of BFD flags based on the information
- in the .subspace directive. */
+ in the .subspace directive. */
applicable = bfd_applicable_section_flags (stdoutput);
flags = 0;
if (loadable)
applicable &= flags;
/* If this is an existing subspace, then we want to use the
- segment already associated with the subspace.
+ segment already associated with the subspace.
- FIXME NOW! ELF BFD doesn't appear to be ready to deal with
- lots of sections. It might be a problem in the PA ELF
- code, I do not know yet. For now avoid creating anything
- but the "standard" sections for ELF. */
+ FIXME NOW! ELF BFD doesn't appear to be ready to deal with
+ lots of sections. It might be a problem in the PA ELF
+ code, I do not know yet. For now avoid creating anything
+ but the "standard" sections for ELF. */
if (ssd)
section = ssd->ssd_seg;
else if (alias)
section = subseg_new (alias, 0);
- else if (! alias && USE_ALIASES)
+ else if (!alias && USE_ALIASES)
{
as_warn ("Ignoring subspace decl due to ELF BFD bugs.");
demand_empty_rest_of_line ();
return;
}
- else
+ else
section = subseg_new (ss_name, 0);
/* Now set the flags. */
/* Set the starting offset for this section. */
bfd_set_section_vma (stdoutput, section,
pa_subspace_start (space, quadrant));
-
+
/* Now that all the flags are set, update an existing subspace,
or create a new one. */
if (ssd)
current_subspace = update_subspace (space, ss_name, loadable,
code_only, common, dup_common,
sort, zero, access, space_index,
- alignment, quadrant,
+ alignment, quadrant,
section);
else
current_subspace = create_new_subspace (space, ss_name, loadable,
code_only, common,
dup_common, zero, sort,
access, space_index,
- alignment, quadrant, section);
+ alignment, quadrant, section);
demand_empty_rest_of_line ();
current_subspace->ssd_seg = section;
subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg);
}
SUBSPACE_DEFINED (current_subspace) = 1;
- return;
}
/* Create default space and subspace dictionaries. */
-static void
+static void
pa_spaces_begin ()
{
int i;
if (pa_def_spaces[i].alias && USE_ALIASES)
name = pa_def_spaces[i].alias;
else
- name = pa_def_spaces[i].name;
+ name = pa_def_spaces[i].name;
pa_def_spaces[i].segment = subseg_new (name, 0);
create_new_space (pa_def_spaces[i].name, pa_def_spaces[i].spnum,
sd_chain_struct *space;
/* Pick the right name for the new section and pick the right
- subsegment number. */
+ subsegment number. */
if (pa_def_subspaces[i].alias && USE_ALIASES)
{
name = pa_def_subspaces[i].alias;
name = pa_def_subspaces[i].name;
subsegment = 0;
}
-
+
/* Create the new section. */
segment = subseg_new (name, subsegment);
/* For SOM we want to replace the standard .text, .data, and .bss
- sections with our own. */
- if (! strcmp (pa_def_subspaces[i].name, "$CODE$") && ! USE_ALIASES)
+ sections with our own. */
+ if (!strcmp (pa_def_subspaces[i].name, "$CODE$") && !USE_ALIASES)
{
text_section = segment;
applicable = bfd_applicable_section_flags (stdoutput);
bfd_set_section_flags (stdoutput, text_section,
- applicable & (SEC_ALLOC | SEC_LOAD
- | SEC_RELOC | SEC_CODE
- | SEC_READONLY
+ applicable & (SEC_ALLOC | SEC_LOAD
+ | SEC_RELOC | SEC_CODE
+ | SEC_READONLY
| SEC_HAS_CONTENTS));
}
- else if (! strcmp (pa_def_subspaces[i].name, "$DATA$") && ! USE_ALIASES)
+ else if (!strcmp (pa_def_subspaces[i].name, "$DATA$") && !USE_ALIASES)
{
data_section = segment;
applicable = bfd_applicable_section_flags (stdoutput);
bfd_set_section_flags (stdoutput, data_section,
- applicable & (SEC_ALLOC | SEC_LOAD
+ applicable & (SEC_ALLOC | SEC_LOAD
| SEC_RELOC
| SEC_HAS_CONTENTS));
-
-
+
+
}
- else if (! strcmp (pa_def_subspaces[i].name, "$BSS$") && ! USE_ALIASES)
+ else if (!strcmp (pa_def_subspaces[i].name, "$BSS$") && !USE_ALIASES)
{
bss_section = segment;
applicable = bfd_applicable_section_flags (stdoutput);
/* Create a new space NAME, with the appropriate flags as defined
- by the given parameters.
-
- Add the new space to the space dictionary chain in numerical
- order as defined by the SORT entries. */
+ by the given parameters. */
static sd_chain_struct *
create_new_space (name, spnum, loadable, defined, private,
SPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
strcpy (SPACE_NAME (chain_entry), name);
- SPACE_NAME_INDEX (chain_entry) = 0;
- SPACE_LOADABLE (chain_entry) = loadable;
SPACE_DEFINED (chain_entry) = defined;
SPACE_USER_DEFINED (chain_entry) = user_defined;
- SPACE_PRIVATE (chain_entry) = private;
SPACE_SPNUM (chain_entry) = spnum;
- SPACE_SORT (chain_entry) = sort;
chain_entry->sd_seg = seg;
chain_entry->sd_last_subseg = -1;
while (chain_pointer)
{
- if (SPACE_SORT (chain_pointer) <= SPACE_SORT (chain_entry))
- {
- prev_chain_pointer = chain_pointer;
- chain_pointer = chain_pointer->sd_next;
- }
- else
- break;
+ prev_chain_pointer = chain_pointer;
+ chain_pointer = chain_pointer->sd_next;
}
/* At this point we've found the correct place to add the new
SUBSPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
strcpy (SUBSPACE_NAME (chain_entry), name);
- SUBSPACE_ACCESS (chain_entry) = access;
- SUBSPACE_LOADABLE (chain_entry) = loadable;
- SUBSPACE_COMMON (chain_entry) = common;
- SUBSPACE_DUP_COMM (chain_entry) = dup_common;
- SUBSPACE_SORT (chain_entry) = sort;
- SUBSPACE_CODE_ONLY (chain_entry) = code_only;
- SUBSPACE_ALIGN (chain_entry) = alignment;
- SUBSPACE_QUADRANT (chain_entry) = quadrant;
- SUBSPACE_SUBSPACE_START (chain_entry) = pa_subspace_start (space, quadrant);
- SUBSPACE_SPACE_INDEX (chain_entry) = space_index;
- SUBSPACE_ZERO (chain_entry) = is_zero;
-
/* Initialize subspace_defined. When we hit a .subspace directive
we'll set it to 1 which "locks-in" the subspace attributes. */
SUBSPACE_DEFINED (chain_entry) = 0;
chain_entry->ssd_subseg = USE_ALIASES ? pa_next_subseg (space) : 0;
chain_entry->ssd_seg = seg;
- chain_entry->ssd_last_align = 1;
chain_entry->ssd_next = NULL;
/* Find spot for the new subspace based on its sort key. */
while (chain_pointer)
{
- if (SUBSPACE_SORT (chain_pointer) <= SUBSPACE_SORT (chain_entry))
- {
- prev_chain_pointer = chain_pointer;
- chain_pointer = chain_pointer->ssd_next;
- }
- else
- break;
-
+ prev_chain_pointer = chain_pointer;
+ chain_pointer = chain_pointer->ssd_next;
}
/* Now we have somewhere to put the new entry. Insert it and update
}
#ifdef obj_set_subsection_attributes
- obj_set_subsection_attributes (seg, space->sd_seg, access,
+ obj_set_subsection_attributes (seg, space->sd_seg, access,
sort, quadrant);
#endif
return chain_entry;
-
}
/* Update the information for the given subspace based upon the
{
ssd_chain_struct *chain_entry;
- if ((chain_entry = is_defined_subspace (name)))
- {
- SUBSPACE_ACCESS (chain_entry) = access;
- SUBSPACE_LOADABLE (chain_entry) = loadable;
- SUBSPACE_COMMON (chain_entry) = common;
- SUBSPACE_DUP_COMM (chain_entry) = dup_common;
- SUBSPACE_CODE_ONLY (chain_entry) = 1;
- SUBSPACE_SORT (chain_entry) = sort;
- SUBSPACE_ALIGN (chain_entry) = alignment;
- SUBSPACE_QUADRANT (chain_entry) = quadrant;
- SUBSPACE_SPACE_INDEX (chain_entry) = space_index;
- SUBSPACE_ZERO (chain_entry) = zero;
- }
- else
- chain_entry = NULL;
+ chain_entry = is_defined_subspace (name);
#ifdef obj_set_subsection_attributes
- obj_set_subsection_attributes (section, space->sd_seg, access,
+ obj_set_subsection_attributes (section, space->sd_seg, access,
sort, quadrant);
#endif
return chain_entry;
-
}
/* Return the space chain entry for the space with the name NAME or
is_defined_subspace (name)
char *name;
{
- sd_chain_struct*space_chain;
+ sd_chain_struct *space_chain;
ssd_chain_struct *subspace_chain;
/* Walk through each space. */
{
/* FIXME. Assumes everyone puts read/write data at 0x4000000, this
is not correct for the PA OSF1 port. */
- if ((strcasecmp (SPACE_NAME (space), "$PRIVATE$") == 0) && quadrant == 1)
+ if ((strcmp (SPACE_NAME (space), "$PRIVATE$") == 0) && quadrant == 1)
return 0x40000000;
else if (space->sd_seg == data_section && quadrant == 1)
return 0x40000000;
pa_undefine_label ();
}
+/* Handle a .COPYRIGHT pseudo-op. */
+
+static void
+pa_copyright (unused)
+ int unused;
+{
+ obj_copyright (0);
+ pa_undefine_label ();
+}
+
/* Just like a normal cons, but when finished we have to undefine
the latest space label. */
pa_undefine_label ();
}
-/* FIXME. What's the purpose of this pseudo-op? */
-
-static void
-pa_desc (unused)
- int unused;
-{
- pa_undefine_label ();
-}
-
/* Like float_cons, but we need to undefine our label. */
-
+
static void
pa_float_cons (float_type)
int float_type;
use it in a relocation -- yuk. */
int
-hppa_fix_adjustable (fixp)
+hppa_fix_adjustable (fixp)
fixS *fixp;
{
struct hppa_fix_struct *hppa_fix;
if (fixp->fx_r_type == R_HPPA && hppa_fix->fx_r_format == 32)
return 0;
- if (fixp->fx_addsy == 0
+ if (fixp->fx_addsy == 0
|| (fixp->fx_addsy->bsym->flags & BSF_FUNCTION) == 0)
return 1;
return 0;
}
-
+
+/* Return nonzero if the fixup in FIXP will require a relocation,
+ even it if appears that the fixup could be completely handled
+ within GAS. */
+
+int
+hppa_force_relocation (fixp)
+ fixS *fixp;
+{
+ struct hppa_fix_struct *hppa_fixp = fixp->tc_fix_data;
+
+#ifdef OBJ_SOM
+ if (fixp->fx_r_type == R_HPPA_ENTRY || fixp->fx_r_type == R_HPPA_EXIT)
+ return 1;
+#endif
+
+#define stub_needed(CALLER, CALLEE) \
+ ((CALLEE) && (CALLER) && ((CALLEE) != (CALLER)))
+
+ /* It is necessary to force PC-relative calls/jumps to have a relocation
+ entry if they're going to need either a argument relocation or long
+ call stub. FIXME. Can't we need the same for absolute calls? */
+ if (fixp->fx_pcrel && fixp->fx_addsy
+ && (stub_needed (((obj_symbol_type *)
+ fixp->fx_addsy->bsym)->tc_data.hppa_arg_reloc,
+ hppa_fixp->fx_arg_reloc)))
+ return 1;
+
+#undef stub_needed
+
+ /* No need (yet) to force another relocations to be emitted. */
+ return 0;
+}
+
/* Now for some ELF specific code. FIXME. */
#ifdef OBJ_ELF
static symext_chainS *symext_rootP;
static symext_chainS *symext_lastP;
+/* Mark the end of a function so that it's possible to compute
+ the size of the function in hppa_elf_final_processing. */
+
+static void
+hppa_elf_mark_end_of_function ()
+{
+ /* ELF does not have EXIT relocations. All we do is create a
+ temporary symbol marking the end of the function. */
+ char *name = (char *)
+ xmalloc (strlen ("L$\001end_") +
+ strlen (S_GET_NAME (last_call_info->start_symbol)) + 1);
+
+ if (name)
+ {
+ symbolS *symbolP;
+
+ strcpy (name, "L$\001end_");
+ strcat (name, S_GET_NAME (last_call_info->start_symbol));
+
+ /* If we have a .exit followed by a .procend, then the
+ symbol will have already been defined. */
+ symbolP = symbol_find (name);
+ if (symbolP)
+ {
+ /* The symbol has already been defined! This can
+ happen if we have a .exit followed by a .procend.
+
+ This is *not* an error. All we want to do is free
+ the memory we just allocated for the name and continue. */
+ xfree (name);
+ }
+ else
+ {
+ /* symbol value should be the offset of the
+ last instruction of the function */
+ symbolP = symbol_new (name, now_seg,
+ (valueT) (obstack_next_free (&frags)
+ - frag_now->fr_literal - 4),
+ frag_now);
+
+ assert (symbolP);
+ symbolP->bsym->flags = BSF_LOCAL;
+ symbol_table_insert (symbolP);
+ }
+
+ if (symbolP)
+ last_call_info->end_symbol = symbolP;
+ else
+ as_bad ("Symbol '%s' could not be created.", name);
+
+ }
+ else
+ as_bad ("No memory for symbol name.");
+
+}
+
/* Do any symbol processing requested by the target-cpu or target-format. */
void
bfd *abfd;
{
symext_chainS *symextP;
- int size, n;
- asection *symextn_sec;
segT save_seg = now_seg;
subsegT save_subseg = now_subseg;
if (symext_rootP == NULL)
return;
- /* Count the number of symbols for the symbol extension section. */
- for (n = 0, symextP = symext_rootP; symextP; symextP = symextP->next, ++n)
- ;
-
- size = sizeof (symext_entryS) * n;
-
/* Switch to the symbol extension section. */
- symextn_sec = subseg_new (SYMEXTN_SECTION_NAME, 0);
+ subseg_new (SYMEXTN_SECTION_NAME, 0);
frag_wane (frag_now);
frag_new (0);
/* Switch back to the original segment. */
subseg_set (save_seg, save_subseg);
-
- return;
}
/* Make the symbol extension section. */
seg = subseg_new (".hppa_symextn", subseg);
bfd_set_section_flags (stdoutput,
seg,
- SEC_HAS_CONTENTS | SEC_READONLY
+ SEC_HAS_CONTENTS | SEC_READONLY
| SEC_ALLOC | SEC_LOAD);
subseg_set (save_seg, save_subseg);
-
}
/* For ELF, this function serves one purpose: to setup the st_size
field of STT_FUNC symbols. To do this, we need to scan the
- call_info structure list, determining st_size in one of two possible
- ways:
-
- 1. call_info->start_frag->fr_fix has the size of the fragment.
- This approach assumes that the function was built into a
- single fragment. This works for most cases, but might fail.
- For example, if there was a segment change in the middle of
- the function.
-
- 2. The st_size field is the difference in the addresses of the
- call_info->start_frag->fr_address field and the fr_address
- field of the next fragment with fr_type == rs_fill and
- fr_fix != 0. */
+ call_info structure list, determining st_size in by taking the
+ difference in the address of the beginning/end marker symbols. */
void
elf_hppa_final_processing ()
call_info_pointer = call_info_pointer->ci_next)
{
elf_symbol_type *esym
- = (elf_symbol_type *) call_info_pointer->start_symbol->bsym;
+ = (elf_symbol_type *) call_info_pointer->start_symbol->bsym;
esym->internal_elf_sym.st_size =
S_GET_VALUE (call_info_pointer->end_symbol)
- - S_GET_VALUE (call_info_pointer->start_symbol) + 4;
+ - S_GET_VALUE (call_info_pointer->start_symbol) + 4;
}
}
#endif
projects / deliverable / binutils-gdb.git / blobdiff