diff options
Diffstat (limited to 'bfd/vms-tir.c')
| -rw-r--r-- | bfd/vms-tir.c | 1559 |
1 files changed, 1065 insertions, 494 deletions
diff --git a/bfd/vms-tir.c b/bfd/vms-tir.c index e6ec6eb..5bc61da 100644 --- a/bfd/vms-tir.c +++ b/bfd/vms-tir.c @@ -1,12 +1,12 @@ /* vms-tir.c -- BFD back-end for VAX (openVMS/VAX) and EVAX (openVMS/Alpha) files. - Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2008 - Free Software Foundation, Inc. + Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007, + 2008, 2009 Free Software Foundation, Inc. TIR record handling functions ETIR record handling functions - go and read the openVMS linker manual (esp. appendix B) + Go and read the openVMS linker manual (esp. appendix B) if you don't know what's going on here :-) Written by Klaus K"ampf (kkaempf@rmi.de) @@ -26,7 +26,6 @@ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ - /* The following type abbreviations are used: cs counted string (ascii string with length byte) @@ -41,6 +40,33 @@ #include "bfdlink.h" #include "libbfd.h" #include "vms.h" + +static int check_section (bfd *, int); +static void image_set_ptr (bfd *abfd, int psect, uquad offset); +static void image_inc_ptr (bfd *abfd, uquad offset); +static void dst_define_location (bfd *abfd, uquad loc); +static void dst_restore_location (bfd *abfd, uquad loc); +static unsigned int dst_retrieve_location (bfd *abfd, uquad loc); +static void dst_check_allocation (bfd *abfd, unsigned int size); +static void image_dump (bfd *abfd, unsigned char *ptr, int size, int offset); +static void image_write_b (bfd *abfd, unsigned int value); +static void image_write_w (bfd *abfd, unsigned int value); +static void image_write_l (bfd *abfd, unsigned long value); +static void image_write_q (bfd *abfd, uquad value); +static bfd_boolean etir_sta (bfd *, int, unsigned char *, int *); +static bfd_boolean etir_sto (bfd *, int, unsigned char *, int *); +static bfd_boolean etir_opr (bfd *, int, unsigned char *, int *); +static bfd_boolean etir_ctl (bfd *, int, unsigned char *, int *); +static bfd_boolean etir_stc (bfd *, int, unsigned char *, int *); +static asection *new_section (bfd *, int); +static int alloc_section (bfd *, unsigned int); +static int etir_cmd (bfd *, int, unsigned char *, int *); +static int analyze_tir (bfd *, unsigned char *, unsigned int); +static int analyze_etir (bfd *, unsigned char *, unsigned int); +static unsigned char *tir_opr (bfd *, unsigned char *); +static const char *tir_cmd_name (int); +static const char *cmd_name (int); + static int check_section (bfd * abfd, int size) @@ -92,6 +118,77 @@ image_inc_ptr (bfd * abfd, uquad offset) PRIV (image_ptr) += offset; } +/* Save current DST location counter under specified index. */ + +static void +dst_define_location (bfd *abfd, uquad loc) +{ + asection *dst_section = PRIV (dst_section); + +#if VMS_DEBUG + _bfd_vms_debug (4, "dst_define_location (%d)\n", (int)loc); +#endif + + /* Grow the ptr offset table if necessary. */ + if (loc + 1 > PRIV (dst_ptr_offsets_count)) + { + PRIV (dst_ptr_offsets) = bfd_realloc (PRIV (dst_ptr_offsets), + (loc + 1) * sizeof (unsigned int)); + PRIV (dst_ptr_offsets_count) = loc + 1; + } + + PRIV (dst_ptr_offsets)[loc] = PRIV (image_ptr) - dst_section->contents; +} + +/* Restore saved DST location counter from specified index. */ + +static void +dst_restore_location (bfd *abfd, uquad loc) +{ + asection *dst_section = PRIV (dst_section); + +#if VMS_DEBUG + _bfd_vms_debug (4, "dst_restore_location (%d)\n", (int)loc); +#endif + + PRIV (image_ptr) = dst_section->contents + PRIV (dst_ptr_offsets)[loc]; +} + +/* Retrieve saved DST location counter from specified index. */ + +static unsigned int +dst_retrieve_location (bfd *abfd, uquad loc) +{ +#if VMS_DEBUG + _bfd_vms_debug (4, "dst_retrieve_location (%d)\n", (int)loc); +#endif + + return PRIV (dst_ptr_offsets)[loc]; +} + +/* Check that the DST section is big enough for the specified + amount of bytes. */ + +static void +dst_check_allocation (bfd *abfd, unsigned int size) +{ + asection *dst_section = PRIV (dst_section); + + bfd_size_type used = PRIV (image_ptr) - dst_section->contents; + bfd_size_type left = dst_section->size - used; + + /* Grow the DST section as necessary */ + if (size > left) + { + dst_section->size *= 2; + dst_section->contents + = bfd_realloc (dst_section->contents, dst_section->size); + PRIV (image_ptr) = dst_section->contents + used; + + dst_check_allocation (abfd, size); + } +} + /* Dump multiple bytes to section image. */ static void @@ -109,6 +206,9 @@ image_dump (bfd * abfd, if (PRIV (is_vax) && check_section (abfd, size)) return; + if (PRIV (dst_section)) + dst_check_allocation (abfd, size); + while (size-- > 0) *PRIV (image_ptr)++ = *ptr++; } @@ -125,6 +225,9 @@ image_write_b (bfd * abfd, unsigned int value) if (PRIV (is_vax) && check_section (abfd, 1)) return; + if (PRIV (dst_section)) + dst_check_allocation (abfd, 1); + *PRIV (image_ptr)++ = (value & 0xff); } @@ -140,6 +243,9 @@ image_write_w (bfd * abfd, unsigned int value) if (PRIV (is_vax) && check_section (abfd, 2)) return; + if (PRIV (dst_section)) + dst_check_allocation (abfd, 2); + bfd_putl16 ((bfd_vma) value, PRIV (image_ptr)); PRIV (image_ptr) += 2; } @@ -156,6 +262,9 @@ image_write_l (bfd * abfd, unsigned long value) if (PRIV (is_vax) && check_section (abfd, 4)) return; + if (PRIV (dst_section)) + dst_check_allocation (abfd, 4); + bfd_putl32 ((bfd_vma) value, PRIV (image_ptr)); PRIV (image_ptr) += 4; } @@ -172,6 +281,9 @@ image_write_q (bfd * abfd, uquad value) if (PRIV (is_vax) && check_section (abfd, 8)) return; + if (PRIV (dst_section)) + dst_check_allocation (abfd, 8); + bfd_putl64 (value, PRIV (image_ptr)); PRIV (image_ptr) += 8; } @@ -182,6 +294,8 @@ cmd_name (int cmd) switch (cmd) { case ETIR_S_C_STA_GBL: return "ETIR_S_C_STA_GBL"; + case ETIR_S_C_STA_LW: return "ETIR_S_C_STA_LW"; + case ETIR_S_C_STA_QW: return "ETIR_S_C_STA_QW"; case ETIR_S_C_STA_PQ: return "ETIR_S_C_STA_PQ"; case ETIR_S_C_STA_LI: return "ETIR_S_C_STA_LI"; case ETIR_S_C_STA_MOD: return "ETIR_S_C_STA_MOD"; @@ -192,10 +306,16 @@ cmd_name (int cmd) case ETIR_S_C_STO_CA: return "ETIR_S_C_STO_CA"; case ETIR_S_C_STO_RB: return "ETIR_S_C_STO_RB"; case ETIR_S_C_STO_AB: return "ETIR_S_C_STO_AB"; + case ETIR_S_C_STO_OFF: return "ETIR_S_C_STO_OFF"; + case ETIR_S_C_STO_IMM: return "ETIR_S_C_STO_IMM"; + case ETIR_S_C_STO_IMMR: return "ETIR_S_C_STO_IMMR"; + case ETIR_S_C_STO_LW: return "ETIR_S_C_STO_LW"; + case ETIR_S_C_STO_QW: return "ETIR_S_C_STO_QW"; case ETIR_S_C_STO_GBL_LW: return "ETIR_S_C_STO_GBL_LW"; case ETIR_S_C_STO_LP_PSB: return "ETIR_S_C_STO_LP_PSB"; case ETIR_S_C_STO_HINT_GBL: return "ETIR_S_C_STO_HINT_GBL"; case ETIR_S_C_STO_HINT_PS: return "ETIR_S_C_STO_HINT_PS"; + case ETIR_S_C_OPR_ADD: return "ETIR_S_C_OPR_ADD"; case ETIR_S_C_OPR_INSV: return "ETIR_S_C_OPR_INSV"; case ETIR_S_C_OPR_USH: return "ETIR_S_C_OPR_USH"; case ETIR_S_C_OPR_ROT: return "ETIR_S_C_OPR_ROT"; @@ -215,34 +335,41 @@ cmd_name (int cmd) case ETIR_S_C_STC_BOH_GBL: return "ETIR_S_C_STC_BOH_GBL"; case ETIR_S_C_STC_BOH_PS: return "ETIR_S_C_STC_BOH_PS"; case ETIR_S_C_STC_NBH_GBL: return "ETIR_S_C_STC_NBH_GBL"; + case ETIR_S_C_CTL_SETRB: return "ETIR_S_C_CTL_SETRB"; + case ETIR_S_C_STC_LP_PSB: return "ETIR_S_C_STC_LP_PSB"; + case ETIR_S_C_CTL_DFLOC: return "ETIR_S_C_CTL_DFLOC"; + case ETIR_S_C_CTL_STLOC: return "ETIR_S_C_CTL_STLOC"; + case ETIR_S_C_CTL_STKDL: return "ETIR_S_C_CTL_STKDL"; default: /* These names have not yet been added to this switch statement. */ - abort (); + (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd); } + + return NULL; } #define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L) /* etir_sta - vms stack commands + Vms stack commands. - handle sta_xxx commands in etir section - ptr points to data area in record + Handle sta_xxx commands in etir section, + ptr points to data area in record. - see table B-8 of the openVMS linker manual. */ + See table B-8 of the openVMS linker manual. */ static bfd_boolean -etir_sta (bfd * abfd, int cmd, unsigned char *ptr) +etir_sta (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs) { #if VMS_DEBUG _bfd_vms_debug (5, "etir_sta %d/%x\n", cmd, cmd); - _bfd_hexdump (8, ptr, 16, (int) ptr); + _bfd_hexdump (8, ptr, 16, (long) ptr); #endif switch (cmd) { - /* stack global + /* Stack global arg: cs symbol name stack 32 bit value of symbol (high bits set to 0). */ @@ -265,37 +392,50 @@ etir_sta (bfd * abfd, int cmd, unsigned char *ptr) else _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1); } + *quarter_relocs = 1; break; - /* stack longword + /* Stack longword arg: lw value stack 32 bit value, sign extend to 64 bit. */ case ETIR_S_C_STA_LW: _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1); + /* This one is special as it is both part of the section header + and of the ALPHA_R_REFLONG relocation. */ + if (bfd_getl16 (ptr - 4 + bfd_getl16 (ptr - 2)) == ETIR_S_C_CTL_DFLOC) + *quarter_relocs = 0; + else if (*quarter_relocs) + *quarter_relocs += 1; + else + *quarter_relocs = 2; break; - /* stack global + /* Stack quadword arg: qw value stack 64 bit value of symbol. */ case ETIR_S_C_STA_QW: _bfd_vms_push (abfd, (uquad) bfd_getl64 (ptr), -1); + if (*quarter_relocs) + *quarter_relocs += 1; + else + *quarter_relocs = 2; break; - /* stack psect base plus quadword offset + /* Stack psect base plus quadword offset arg: lw section index qw signed quadword offset (low 32 bits) - stack qw argument and section index + Stack qw argument and section index (see ETIR_S_C_STO_OFF, ETIR_S_C_CTL_SETRB). */ case ETIR_S_C_STA_PQ: { uquad dummy; - unsigned int psect; + int psect; psect = bfd_getl32 (ptr); - if (psect >= PRIV (section_count)) + if ((unsigned int) psect >= PRIV (section_count)) { (*_bfd_error_handler) (_("bad section index in %s"), cmd_name (cmd)); @@ -305,23 +445,31 @@ etir_sta (bfd * abfd, int cmd, unsigned char *ptr) dummy = bfd_getl64 (ptr + 4); _bfd_vms_push (abfd, dummy, (int) psect); } + /* This one is special as it is both part of the section header + and of the ALPHA_R_REFLONG and ALPHA_R_REFQUAD relocations. */ + if (bfd_getl16 (ptr - 4 + bfd_getl16 (ptr - 2)) == ETIR_S_C_CTL_SETRB) + *quarter_relocs = 0; + else + *quarter_relocs = 2; break; case ETIR_S_C_STA_LI: case ETIR_S_C_STA_MOD: case ETIR_S_C_STA_CKARG: (*_bfd_error_handler) (_("unsupported STA cmd %s"), cmd_name (cmd)); + *quarter_relocs = 0; return FALSE; - break; default: (*_bfd_error_handler) (_("reserved STA cmd %d"), cmd); + *quarter_relocs = 0; return FALSE; - break; } + #if VMS_DEBUG _bfd_vms_debug (5, "etir_sta true\n"); #endif + return TRUE; } @@ -335,14 +483,14 @@ etir_sta (bfd * abfd, int cmd, unsigned char *ptr) see table B-9 of the openVMS linker manual. */ static bfd_boolean -etir_sto (bfd * abfd, int cmd, unsigned char *ptr) +etir_sto (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs) { uquad dummy; int psect; #if VMS_DEBUG _bfd_vms_debug (5, "etir_sto %d/%x\n", cmd, cmd); - _bfd_hexdump (8, ptr, 16, (int) ptr); + _bfd_hexdump (8, ptr, 16, (long) ptr); #endif switch (cmd) @@ -353,6 +501,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr) dummy = _bfd_vms_pop (abfd, &psect); /* FIXME: check top bits. */ image_write_b (abfd, (unsigned int) dummy & 0xff); + *quarter_relocs = 0; break; /* Store word: pop stack, write word @@ -361,6 +510,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr) dummy = _bfd_vms_pop (abfd, &psect); /* FIXME: check top bits */ image_write_w (abfd, (unsigned int) dummy & 0xffff); + *quarter_relocs = 0; break; /* Store longword: pop stack, write longword @@ -370,6 +520,10 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr) dummy += (PRIV (sections)[psect])->vma; /* FIXME: check top bits. */ image_write_l (abfd, (unsigned int) dummy & 0xffffffff); + if (*quarter_relocs == 2) + *quarter_relocs = 4; + else + *quarter_relocs += 1; break; /* Store quadword: pop stack, write quadword @@ -379,6 +533,10 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr) dummy += (PRIV (sections)[psect])->vma; /* FIXME: check top bits. */ image_write_q (abfd, dummy); + if (*quarter_relocs == 2) + *quarter_relocs = 4; + else + *quarter_relocs += 1; break; /* Store immediate repeated: pop stack for repeat count @@ -393,6 +551,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr) while (dummy-- > 0) image_dump (abfd, ptr+4, size, 0); } + *quarter_relocs = 0; break; /* Store global: write symbol value @@ -406,15 +565,13 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr) entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE); if (entry == NULL) - { - (*_bfd_error_handler) (_("%s: no symbol \"%s\""), - cmd_name (cmd), name); - return FALSE; - } + /* FIXME, reloc. */ + image_write_q (abfd, (uquad) (0)); else /* FIXME, reloc. */ image_write_q (abfd, (uquad) (entry->symbol->value)); } + *quarter_relocs = 4; break; /* Store code address: write address of entry point @@ -428,15 +585,13 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr) entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE); if (entry == NULL) - { - (*_bfd_error_handler) (_("%s: no symbol \"%s\""), - cmd_name (cmd), name); - return FALSE; - } + /* FIXME, reloc. */ + image_write_q (abfd, (uquad) (0)); else /* FIXME, reloc. */ image_write_q (abfd, (uquad) (entry->symbol->value)); } + *quarter_relocs = 4; break; /* Store offset to psect: pop stack, add low 32 bits to base of psect @@ -450,6 +605,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr) q += (PRIV (sections)[psect1])->vma; image_write_q (abfd, q); } + *quarter_relocs += 2; break; /* Store immediate @@ -462,6 +618,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr) size = bfd_getl32 (ptr); image_dump (abfd, ptr+4, size, 0); } + *quarter_relocs = 0; break; /* This code is 'reserved to digital' according to the openVMS @@ -489,22 +646,26 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr) /* FIXME, reloc. */ image_write_l (abfd, (unsigned long) (entry->symbol->value)); } + *quarter_relocs = 4; break; case ETIR_S_C_STO_RB: case ETIR_S_C_STO_AB: case ETIR_S_C_STO_LP_PSB: (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd)); - break; + *quarter_relocs = 0; + return FALSE; case ETIR_S_C_STO_HINT_GBL: case ETIR_S_C_STO_HINT_PS: (*_bfd_error_handler) (_("%s: not implemented"), cmd_name (cmd)); - break; + *quarter_relocs = 0; + return FALSE; default: (*_bfd_error_handler) (_("reserved STO cmd %d"), cmd); - break; + *quarter_relocs = 0; + return FALSE; } return TRUE; @@ -518,15 +679,22 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr) see table B-10 of the openVMS linker manual. */ static bfd_boolean -etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED) +etir_opr (bfd *abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED, + int *quarter_relocs) { long op1, op2; #if VMS_DEBUG _bfd_vms_debug (5, "etir_opr %d/%x\n", cmd, cmd); - _bfd_hexdump (8, ptr, 16, (int) ptr); + _bfd_hexdump (8, ptr, 16, (long) ptr); #endif + /* No relocation uses OPR commands except ETIR_S_C_OPR_ADD. */ + if (cmd == ETIR_S_C_OPR_ADD) + *quarter_relocs += 1; + else + *quarter_relocs = 0; + switch (cmd) { case ETIR_S_C_OPR_NOP: /* No-op. */ @@ -604,7 +772,7 @@ etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED) case ETIR_S_C_OPR_REDEF: /* Redefine symbol to current location. */ case ETIR_S_C_OPR_DFLIT: /* Define a literal. */ (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd)); - break; + return FALSE; case ETIR_S_C_OPR_SEL: /* Select. */ if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L) @@ -619,7 +787,7 @@ etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED) default: (*_bfd_error_handler) (_("reserved OPR cmd %d"), cmd); - break; + return FALSE; } return TRUE; @@ -630,16 +798,19 @@ etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED) See table B-11 of the openVMS linker manual. */ static bfd_boolean -etir_ctl (bfd * abfd, int cmd, unsigned char *ptr) +etir_ctl (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs) { - uquad dummy; + uquad dummy; int psect; #if VMS_DEBUG _bfd_vms_debug (5, "etir_ctl %d/%x\n", cmd, cmd); - _bfd_hexdump (8, ptr, 16, (int) ptr); + _bfd_hexdump (8, ptr, 16, (long) ptr); #endif + /* No relocation uses CTL commands. */ + *quarter_relocs = 0; + switch (cmd) { /* Det relocation base: pop stack, set image location counter @@ -660,27 +831,28 @@ etir_ctl (bfd * abfd, int cmd, unsigned char *ptr) arg: none. */ case ETIR_S_C_CTL_DFLOC: dummy = _bfd_vms_pop (abfd, NULL); - /* FIXME */ + dst_define_location (abfd, dummy); break; /* Set location: pop index, restore location counter from index arg: none. */ case ETIR_S_C_CTL_STLOC: - dummy = _bfd_vms_pop (abfd, &psect); - /* FIXME */ + dummy = _bfd_vms_pop (abfd, NULL); + dst_restore_location (abfd, dummy); break; /* Stack defined location: pop index, push location counter from index arg: none. */ case ETIR_S_C_CTL_STKDL: - dummy = _bfd_vms_pop (abfd, &psect); - /* FIXME. */ + dummy = _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, dst_retrieve_location (abfd, dummy), -1); break; default: (*_bfd_error_handler) (_("reserved CTL cmd %d"), cmd); - break; + return FALSE; } + return TRUE; } @@ -689,11 +861,12 @@ etir_ctl (bfd * abfd, int cmd, unsigned char *ptr) See table B-12 and B-13 of the openVMS linker manual. */ static bfd_boolean -etir_stc (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED) +etir_stc (bfd *abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED, + int *quarter_relocs) { #if VMS_DEBUG _bfd_vms_debug (5, "etir_stc %d/%x\n", cmd, cmd); - _bfd_hexdump (8, ptr, 16, (int) ptr); + _bfd_hexdump (8, ptr, 16, (long) ptr); #endif switch (cmd) @@ -701,32 +874,17 @@ etir_stc (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED) /* 200 Store-conditional Linkage Pair arg: none. */ case ETIR_S_C_STC_LP: - (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd)); - break; - - /* 201 Store-conditional Linkage Pair with Procedure Signature - arg: lw linkage index - cs procedure name - by signature length - da signature. */ - case ETIR_S_C_STC_LP_PSB: - image_inc_ptr (abfd, (uquad) 16); /* skip entry,procval */ - break; /* 202 Store-conditional Address at global address arg: lw linkage index cs global name. */ case ETIR_S_C_STC_GBL: - (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd)); - break; /* 203 Store-conditional Code Address at global address arg: lw linkage index cs procedure name. */ case ETIR_S_C_STC_GCA: - (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd)); - break; /* 204 Store-conditional Address at psect + offset arg: lw linkage index @@ -734,56 +892,82 @@ etir_stc (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED) qw offset. */ case ETIR_S_C_STC_PS: (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd)); + *quarter_relocs = 0; + return FALSE; + + /* 201 Store-conditional Linkage Pair with Procedure Signature + arg: lw linkage index + cs procedure name + by signature length + da signature. */ + + case ETIR_S_C_STC_LP_PSB: + image_inc_ptr (abfd, (uquad) 16); /* skip entry,procval */ + *quarter_relocs = 4; break; /* 205 Store-conditional NOP at address of global arg: none. */ case ETIR_S_C_STC_NOP_GBL: - - /* 206 Store-conditional NOP at pect + offset - arg: none. */ - case ETIR_S_C_STC_NOP_PS: + /* ALPHA_R_NOP */ /* 207 Store-conditional BSR at global address arg: none. */ - case ETIR_S_C_STC_BSR_GBL: - /* 208 Store-conditional BSR at pect + offset - arg: none. */ - case ETIR_S_C_STC_BSR_PS: + case ETIR_S_C_STC_BSR_GBL: + /* ALPHA_R_BSR */ /* 209 Store-conditional LDA at global address arg: none. */ - case ETIR_S_C_STC_LDA_GBL: - /* 210 Store-conditional LDA at psect + offset - arg: none. */ - case ETIR_S_C_STC_LDA_PS: + case ETIR_S_C_STC_LDA_GBL: + /* ALPHA_R_LDA */ /* 211 Store-conditional BSR or Hint at global address arg: none. */ - case ETIR_S_C_STC_BOH_GBL: - /* 212 Store-conditional BSR or Hint at pect + offset - arg: none. */ - case ETIR_S_C_STC_BOH_PS: + case ETIR_S_C_STC_BOH_GBL: + *quarter_relocs = 4; + break; /* 213 Store-conditional NOP,BSR or HINT at global address arg: none. */ + case ETIR_S_C_STC_NBH_GBL: - /* 214 Store-conditional NOP,BSR or HINT at psect + offset + /* 206 Store-conditional NOP at pect + offset + arg: none. */ + + case ETIR_S_C_STC_NOP_PS: + + /* 208 Store-conditional BSR at pect + offset + arg: none. */ + + case ETIR_S_C_STC_BSR_PS: + + /* 210 Store-conditional LDA at psect + offset + arg: none. */ + + case ETIR_S_C_STC_LDA_PS: + + /* 212 Store-conditional BSR or Hint at pect + offset + arg: none. */ + + case ETIR_S_C_STC_BOH_PS: + + /* 214 Store-conditional NOP, BSR or HINT at psect + offset arg: none. */ case ETIR_S_C_STC_NBH_PS: - /* FIXME */ - break; + (*_bfd_error_handler) ("%s: not supported", cmd_name (cmd)); + *quarter_relocs = 0; + return FALSE; default: -#if VMS_DEBUG - _bfd_vms_debug (3, "reserved STC cmd %d", cmd); -#endif - break; + (*_bfd_error_handler) (_("reserved STC cmd %d"), cmd); + *quarter_relocs = 0; + return FALSE; } + return TRUE; } @@ -851,10 +1035,10 @@ alloc_section (bfd * abfd, unsigned int idx) /* tir_sta - vax stack commands + Vax stack commands. - Handle sta_xxx commands in tir section - ptr points to data area in record + Handle sta_xxx commands in tir section, + ptr points to data area in record. See table 7-3 of the VAX/VMS linker manual. */ @@ -924,7 +1108,7 @@ tir_sta (bfd * abfd, unsigned char *ptr) by signed byte offset. */ { unsigned long dummy; - unsigned int psect; + int psect; if (cmd == TIR_S_C_STA_PB) psect = *ptr++; @@ -934,12 +1118,12 @@ tir_sta (bfd * abfd, unsigned char *ptr) ptr += 2; } - if (psect >= PRIV (section_count)) + if ((unsigned int) psect >= PRIV (section_count)) alloc_section (abfd, psect); dummy = (long) *ptr++; dummy += (PRIV (sections)[psect])->vma; - _bfd_vms_push (abfd, (uquad) dummy, (int) psect); + _bfd_vms_push (abfd, (uquad) dummy, psect); } break; @@ -951,7 +1135,7 @@ tir_sta (bfd * abfd, unsigned char *ptr) sh signed short offset. */ { unsigned long dummy; - unsigned int psect; + int psect; if (cmd == TIR_S_C_STA_PW) psect = *ptr++; @@ -961,12 +1145,12 @@ tir_sta (bfd * abfd, unsigned char *ptr) ptr += 2; } - if (psect >= PRIV (section_count)) + if ((unsigned int) psect >= PRIV (section_count)) alloc_section (abfd, psect); dummy = bfd_getl16 (ptr); ptr+=2; dummy += (PRIV (sections)[psect])->vma; - _bfd_vms_push (abfd, (uquad) dummy, (int) psect); + _bfd_vms_push (abfd, (uquad) dummy, psect); } break; @@ -978,7 +1162,7 @@ tir_sta (bfd * abfd, unsigned char *ptr) lw signed longword offset. */ { unsigned long dummy; - unsigned int psect; + int psect; if (cmd == TIR_S_C_STA_PL) psect = *ptr++; @@ -988,12 +1172,12 @@ tir_sta (bfd * abfd, unsigned char *ptr) ptr += 2; } - if (psect >= PRIV (section_count)) + if ((unsigned int) psect >= PRIV (section_count)) alloc_section (abfd, psect); dummy = bfd_getl32 (ptr); ptr += 4; dummy += (PRIV (sections)[psect])->vma; - _bfd_vms_push (abfd, (uquad) dummy, (int) psect); + _bfd_vms_push (abfd, (uquad) dummy, psect); } break; @@ -1457,7 +1641,7 @@ static unsigned char * tir_ctl (bfd * abfd, unsigned char *ptr) { unsigned long dummy; - unsigned int psect; + int psect; #if VMS_DEBUG _bfd_vms_debug (5, "tir_ctl %d\n", *ptr); @@ -1468,10 +1652,10 @@ tir_ctl (bfd * abfd, unsigned char *ptr) case TIR_S_C_CTL_SETRB: /* Set relocation base: pop stack, set image location counter arg: none. */ - dummy = _bfd_vms_pop (abfd, (int *) &psect); - if (psect >= PRIV (section_count)) + dummy = _bfd_vms_pop (abfd, &psect); + if ((unsigned int) psect >= PRIV (section_count)) alloc_section (abfd, psect); - image_set_ptr (abfd, (int) psect, (uquad) dummy); + image_set_ptr (abfd, psect, (uquad) dummy); break; case TIR_S_C_CTL_AUGRB: @@ -1492,7 +1676,7 @@ tir_ctl (bfd * abfd, unsigned char *ptr) case TIR_S_C_CTL_STLOC: /* Set location: pop index, restore location counter from index arg: none. */ - dummy = _bfd_vms_pop (abfd, (int *) &psect); + dummy = _bfd_vms_pop (abfd, &psect); (*_bfd_error_handler) (_("%s: not fully implemented"), tir_cmd_name (ptr[-1])); break; @@ -1500,7 +1684,7 @@ tir_ctl (bfd * abfd, unsigned char *ptr) case TIR_S_C_CTL_STKDL: /* Stack defined location: pop index, push location counter from index arg: none. */ - dummy = _bfd_vms_pop (abfd, (int *) &psect); + dummy = _bfd_vms_pop (abfd, &psect); (*_bfd_error_handler) (_("%s: not fully implemented"), tir_cmd_name (ptr[-1])); break; @@ -1517,7 +1701,7 @@ tir_ctl (bfd * abfd, unsigned char *ptr) static unsigned char * tir_cmd (bfd * abfd, unsigned char *ptr) { - struct + static const struct { int mincod; int maxcod; @@ -1535,7 +1719,7 @@ tir_cmd (bfd * abfd, unsigned char *ptr) #if VMS_DEBUG _bfd_vms_debug (4, "tir_cmd %d/%x\n", *ptr, *ptr); - _bfd_hexdump (8, ptr, 16, (int) ptr); + _bfd_hexdump (8, ptr, 16, (long) ptr); #endif if (*ptr & 0x80) @@ -1570,13 +1754,13 @@ tir_cmd (bfd * abfd, unsigned char *ptr) /* Handle command from ETIR section. */ static int -etir_cmd (bfd * abfd, int cmd, unsigned char *ptr) +etir_cmd (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs) { - static struct + static const struct { int mincod; int maxcod; - bfd_boolean (*explain) (bfd *, int, unsigned char *); + bfd_boolean (*explain) (bfd *, int, unsigned char *, int *); } etir_table[] = { @@ -1591,8 +1775,8 @@ etir_cmd (bfd * abfd, int cmd, unsigned char *ptr) int i = 0; #if VMS_DEBUG - _bfd_vms_debug (4, "etir_cmd %d/%x\n", cmd, cmd); - _bfd_hexdump (8, ptr, 16, (int) ptr); + _bfd_vms_debug (4, "etir_cmd: %s(%d)\n", cmd_name (cmd), cmd); + _bfd_hexdump (8, ptr, 16, (long) ptr); #endif while (etir_table[i].mincod >= 0) @@ -1600,7 +1784,7 @@ etir_cmd (bfd * abfd, int cmd, unsigned char *ptr) if ( (etir_table[i].mincod <= cmd) && (cmd <= etir_table[i].maxcod)) { - if (!etir_table[i].explain (abfd, cmd, ptr)) + if (!etir_table[i].explain (abfd, cmd, ptr, quarter_relocs)) return -1; break; } @@ -1608,7 +1792,7 @@ etir_cmd (bfd * abfd, int cmd, unsigned char *ptr) } #if VMS_DEBUG - _bfd_vms_debug (4, "etir_cmd: = 0\n"); + _bfd_vms_debug (4, "etir_cmd: result = 0\n"); #endif return 0; } @@ -1643,28 +1827,67 @@ analyze_tir (bfd * abfd, unsigned char *ptr, unsigned int length) static int analyze_etir (bfd * abfd, unsigned char *ptr, unsigned int length) { - int cmd; - unsigned char *maxptr; + unsigned char *maxptr = ptr + length; + /* Relocations are made of 1, 2 or 4 ETIR commands. + We therefore count them using quarters. */ + int quarter_relocs = 0; int result = 0; #if VMS_DEBUG _bfd_vms_debug (3, "analyze_etir: %d bytes\n", length); #endif - maxptr = ptr + length; - while (ptr < maxptr) { - cmd = bfd_getl16 (ptr); - length = bfd_getl16 (ptr + 2); - result = etir_cmd (abfd, cmd, ptr+4); + int cmd = bfd_getl16 (ptr); + int cmd_length = bfd_getl16 (ptr + 2); + result = etir_cmd (abfd, cmd, ptr + 4, &quarter_relocs); if (result != 0) break; - ptr += length; + + /* If we have a relocation, we record its length to size + future buffers and bump the reloc count of the section. */ + if (quarter_relocs) + { + vms_section_data (PRIV (image_section))->reloc_size += cmd_length; + abfd->flags |= HAS_RELOC; + + if (quarter_relocs == 4) + { + PRIV (image_section)->reloc_count++; + +#if VMS_DEBUG + _bfd_vms_debug (4, "-> reloc %d at 0x%x\n", + PRIV (image_section)->reloc_count-1, + ptr - (maxptr - length)); +#endif + + quarter_relocs = 0; + } + else if (quarter_relocs > 4) + { + +#if VMS_DEBUG + _bfd_vms_debug (4, "Reloc count error (%d) in section %s\n", + PRIV (image_section)->reloc_count, + PRIV (image_section)->name); +#endif + + quarter_relocs = 0; + } + } + + /* If we have a Store Immediate, we reserve space for the + count argument. */ + else if (cmd == ETIR_S_C_STO_IMM) + vms_section_data (PRIV (image_section))->reloc_size + += ETIR_S_C_HEADER_SIZE + 4; + + ptr += cmd_length; } #if VMS_DEBUG - _bfd_vms_debug (3, "analyze_etir: = %d\n", result); + _bfd_vms_debug (3, "analyze_etir: result = %d\n", result); #endif return result; @@ -1685,8 +1908,8 @@ _bfd_vms_slurp_tir (bfd * abfd, int objtype) switch (objtype) { case EOBJ_S_C_ETIR: - PRIV (vms_rec) += 4; /* Skip type, size. */ - PRIV (rec_size) -= 4; + PRIV (vms_rec) += ETIR_S_C_HEADER_SIZE; + PRIV (rec_size) -= ETIR_S_C_HEADER_SIZE; result = analyze_etir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size)); break; case OBJ_S_C_TIR: @@ -1702,33 +1925,361 @@ _bfd_vms_slurp_tir (bfd * abfd, int objtype) return result; } -/* Process EDBG record - Return 0 on success, -1 on error - - Not implemented yet. */ + /* Slurp relocs from ETIR sections and (temporarily) save them + in the per-section reloc buffer. */ int -_bfd_vms_slurp_dbg (bfd * abfd, int objtype ATTRIBUTE_UNUSED) +_bfd_vms_slurp_relocs (bfd *abfd) { + struct vms_section_data_struct *vsd; + unsigned char *begin = PRIV (vms_rec) + 4; + unsigned char *end = PRIV (vms_rec) + PRIV (rec_size); + unsigned char *ptr; + int cmd, length, slurped_length; + #if VMS_DEBUG - _bfd_vms_debug (2, "DBG/EDBG\n"); + _bfd_vms_debug (3, "_bfd_vms_slurp_relocs: %d bytes\n", PRIV (rec_size)); +#endif + + for (ptr = begin; ptr < end; ptr += length) + { + cmd = bfd_getl16 (ptr); + length = bfd_getl16 (ptr + 2); + slurped_length = length; + + switch (cmd) + { + case ETIR_S_C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */ + /* This one is special as it is both part of the section header + and of the ALPHA_R_REFLONG and ALPHA_R_REFQUAD relocations. */ + if (bfd_getl16 (ptr + length) == ETIR_S_C_CTL_SETRB) + { + int psect = bfd_getl32 (ptr + ETIR_S_C_HEADER_SIZE); + PRIV (image_section) = PRIV (sections)[psect]; + continue; + } + + case ETIR_S_C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */ + /* ALPHA_R_REFQUAD und_section, step 1 */ + break; + + case ETIR_S_C_STA_LW: /* ALPHA_R_REFLONG und_section, step 2 */ + /* ALPHA_R_REFLONG abs_section, step 1 */ + /* This one is special as it is both part of the section header + and of the ALPHA_R_REFLONG relocation. */ + if (bfd_getl16 (ptr + length) == ETIR_S_C_CTL_DFLOC) + { + PRIV (image_section) = PRIV (dst_section); + continue; + } + + case ETIR_S_C_STA_QW: /* ALPHA_R_REFQUAD und_section, step 2 */ + /* ALPHA_R_REFQUAD abs_section, step 1 */ + + case ETIR_S_C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */ + /* ALPHA_R_REFLONG abs_section, step 2 */ + /* ALPHA_R_REFLONG others, step 2 */ + + case ETIR_S_C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */ + /* ALPHA_R_REFQUAD abs_section, step 2 */ + + case ETIR_S_C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */ + + case ETIR_S_C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */ + /* ALPHA_R_REFQUAD und_section, step 3 */ + + case ETIR_S_C_STO_CA: /* ALPHA_R_CODEADDR */ + case ETIR_S_C_STO_GBL: /* ALPHA_R_REFQUAD und_section */ + case ETIR_S_C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */ + case ETIR_S_C_STC_LP_PSB: /* ALPHA_R_LINKAGE */ + case ETIR_S_C_STC_NOP_GBL: /* ALPHA_R_NOP */ + case ETIR_S_C_STC_BSR_GBL: /* ALPHA_R_BSR */ + case ETIR_S_C_STC_LDA_GBL: /* ALPHA_R_LDA */ + case ETIR_S_C_STC_BOH_GBL: /* ALPHA_R_BOH */ + break; + + case ETIR_S_C_STO_IMM: + if (PRIV (image_section)->reloc_count == 0) + continue; + /* This is not a relocation, but we nevertheless slurp the + count argument. We'll use it to compute the addresses + of the relocations. */ + slurped_length = ETIR_S_C_HEADER_SIZE + 4; + break; + + default: + continue; + } + + vsd = vms_section_data (PRIV (image_section)); + memcpy (vsd->reloc_stream + vsd->reloc_offset, ptr, slurped_length); + vsd->reloc_offset += slurped_length; + if (vsd->reloc_offset > vsd->reloc_size) + { + (*_bfd_error_handler) (_("Reloc size error in section %s"), + PRIV (image_section)->name); + return -1; + } + } + +#if VMS_DEBUG + _bfd_vms_debug (3, "_bfd_vms_slurp_relocs: result = 0\n"); #endif - abfd->flags |= (HAS_DEBUG | HAS_LINENO); return 0; } -/* Process ETBT record - Return 0 on success, -1 on error - - Not implemented yet. */ +/* Decode relocs from the reloc buffer of the specified section + and internalize them in the specified buffer. */ int -_bfd_vms_slurp_tbt (bfd * abfd ATTRIBUTE_UNUSED, - int objtype ATTRIBUTE_UNUSED) +_bfd_vms_decode_relocs (bfd *abfd, arelent *relocs, asection *section, + asymbol **symbols ATTRIBUTE_UNUSED) { + int saved_cmd, saved_sym_offset, saved_sec_offset, saved_addend_offset; + int cmd, sym_offset, sec_offset, address_offset, addend_offset; + struct vms_section_data_struct *vsd = vms_section_data (section); + bfd_reloc_code_real_type reloc_code; + vms_symbol_entry *entry; + bfd_vma vaddr = 0; + unsigned char *begin = vsd->reloc_stream; + unsigned char *end = vsd->reloc_stream + vsd->reloc_size; + unsigned char *ptr, *arg_ptr; + const char *name; + int length; + #if VMS_DEBUG - _bfd_vms_debug (2, "TBT/ETBT\n"); + _bfd_vms_debug (3, "_bfd_vms_decode_relocs: %d bytes\n", vsd->reloc_size); +#endif + + #define PUSH_CMD() \ + { \ + saved_cmd = cmd; \ + saved_sym_offset = sym_offset - length; \ + saved_sec_offset = sec_offset - length; \ + saved_addend_offset = addend_offset - length; \ + continue; \ + } + + #define POP_CMD() \ + { \ + cmd = saved_cmd; \ + saved_cmd = ETIR_S_C_MAXSTCCOD + 1; \ + sym_offset = saved_sym_offset; \ + sec_offset = saved_sec_offset; \ + addend_offset= saved_addend_offset; \ + } + + #define CMD_PUSHED (saved_cmd != ETIR_S_C_MAXSTCCOD + 1) + + #define NO_OFFSET -128 + + saved_cmd = ETIR_S_C_MAXSTCCOD + 1; + saved_sym_offset = NO_OFFSET; + saved_sec_offset = NO_OFFSET; + saved_addend_offset = NO_OFFSET; + + for (ptr = begin; ptr < end; ptr += length) + { + cmd = bfd_getl16 (ptr); + length = bfd_getl16 (ptr + 2); + + arg_ptr = ptr + ETIR_S_C_HEADER_SIZE; + sym_offset = NO_OFFSET; + sec_offset = NO_OFFSET; + address_offset = NO_OFFSET; + addend_offset = NO_OFFSET; + + switch (cmd) + { + case ETIR_S_C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */ + /* ALPHA_R_REFQUAD und_section, step 1 */ + sym_offset = 0; + PUSH_CMD () + + case ETIR_S_C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */ + sec_offset = 0; + addend_offset = 4; + PUSH_CMD () + + case ETIR_S_C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */ + /* ALPHA_R_REFLONG und_section, step 2 */ + if (CMD_PUSHED) + { + POP_CMD () + if (cmd != ETIR_S_C_STA_GBL) + { + (*_bfd_error_handler) (_("Unknown reloc %s + %s"), + cmd_name (cmd), + cmd_name (ETIR_S_C_STA_LW)); + return 0; + } + cmd = ETIR_S_C_STA_LW; + } + addend_offset = 0; + PUSH_CMD () + + case ETIR_S_C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */ + /* ALPHA_R_REFQUAD und_section, step 2 */ + if (CMD_PUSHED) + { + POP_CMD () + if (cmd != ETIR_S_C_STA_GBL) + { + (*_bfd_error_handler) (_("Unknown reloc %s + %s"), + cmd_name (cmd), + cmd_name (ETIR_S_C_STA_QW)); + return 0; + } + cmd = ETIR_S_C_STA_QW; + } + addend_offset = 0; + PUSH_CMD () + + case ETIR_S_C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */ + /* ALPHA_R_REFLONG abs_section, step 2 */ + /* ALPHA_R_REFLONG others, step 2 */ + POP_CMD () + if (cmd != ETIR_S_C_OPR_ADD + && cmd != ETIR_S_C_STA_LW + && cmd != ETIR_S_C_STA_PQ) + { + (*_bfd_error_handler) (_("Unknown reloc %s + %s"), + cmd_name (cmd), cmd_name (ETIR_S_C_STO_LW)); + return 0; + } + reloc_code = BFD_RELOC_32; + break; + + case ETIR_S_C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */ + /* ALPHA_R_REFQUAD abs_section, step 2 */ + POP_CMD () + if (cmd != ETIR_S_C_OPR_ADD && cmd != ETIR_S_C_STA_QW) + { + (*_bfd_error_handler) (_("Unknown reloc %s + %s"), + cmd_name (cmd), cmd_name (ETIR_S_C_STO_QW)); + return 0; + } + reloc_code = BFD_RELOC_64; + break; + + case ETIR_S_C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */ + POP_CMD () + if (cmd != ETIR_S_C_STA_PQ) + { + (*_bfd_error_handler) (_("Unknown reloc %s + %s"), + cmd_name (cmd), cmd_name (ETIR_S_C_STO_OFF)); + return 0; + } + reloc_code = BFD_RELOC_64; + break; + + case ETIR_S_C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */ + /* ALPHA_R_REFQUAD und_section, step 3 */ + POP_CMD () + if (cmd != ETIR_S_C_STA_LW && cmd != ETIR_S_C_STA_QW) + { + (*_bfd_error_handler) (_("Unknown reloc %s + %s"), + cmd_name (cmd), cmd_name (ETIR_S_C_OPR_ADD)); + return 0; + } + cmd = ETIR_S_C_OPR_ADD; + PUSH_CMD () + + case ETIR_S_C_STO_CA: /* ALPHA_R_CODEADDR */ + reloc_code = BFD_RELOC_ALPHA_CODEADDR; + sym_offset = 0; + break; + + case ETIR_S_C_STO_GBL: /* ALPHA_R_REFQUAD und_section */ + reloc_code = BFD_RELOC_64; + sym_offset = 0; + break; + + case ETIR_S_C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */ + reloc_code = BFD_RELOC_32; + sym_offset = 0; + break; + + case ETIR_S_C_STC_LP_PSB: /* ALPHA_R_LINKAGE */ + reloc_code = BFD_RELOC_ALPHA_LINKAGE; + sym_offset = 4; + break; + + case ETIR_S_C_STC_NOP_GBL: /* ALPHA_R_NOP */ + reloc_code = BFD_RELOC_ALPHA_NOP; + goto call_reloc; + + case ETIR_S_C_STC_BSR_GBL: /* ALPHA_R_BSR */ + reloc_code = BFD_RELOC_ALPHA_BSR; + goto call_reloc; + + case ETIR_S_C_STC_LDA_GBL: /* ALPHA_R_LDA */ + reloc_code = BFD_RELOC_ALPHA_LDA; + goto call_reloc; + + case ETIR_S_C_STC_BOH_GBL: /* ALPHA_R_BOH */ + reloc_code = BFD_RELOC_ALPHA_BOH; + goto call_reloc; + + call_reloc: + sym_offset = 32; + address_offset = 8; + addend_offset = 24; + break; + + case ETIR_S_C_STO_IMM: + vaddr += bfd_getl32 (arg_ptr); + length = ETIR_S_C_HEADER_SIZE + 4; + continue; + + default: + continue; + } + + relocs->howto = bfd_reloc_type_lookup (abfd, reloc_code); + + if (sym_offset > NO_OFFSET) + { + name = _bfd_vms_save_counted_string (arg_ptr + sym_offset); + entry = (vms_symbol_entry *) + bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE); + if (entry == NULL) + { + (*_bfd_error_handler) (_("Unknown symbol %s in command %s"), + name, cmd_name (cmd)); + relocs->sym_ptr_ptr = NULL; + } + else + /* ??? This is a hack. We should point in 'symbols'. */ + relocs->sym_ptr_ptr = &entry->symbol; + } + else if (sec_offset > NO_OFFSET) + relocs->sym_ptr_ptr + = PRIV (sections)[bfd_getl32 (arg_ptr + sec_offset)]->symbol_ptr_ptr; + else + relocs->sym_ptr_ptr = NULL; + + if (address_offset > NO_OFFSET) + relocs->address = bfd_getl64 (arg_ptr + address_offset); + else + relocs->address = vaddr; + + if (addend_offset > NO_OFFSET) + relocs->addend = bfd_getl64 (arg_ptr + addend_offset); + else + relocs->addend = 0; + + vaddr += bfd_get_reloc_size (relocs->howto); + relocs++; + } + + #undef PUSH_CMD + #undef POP_CMD + #undef NO_OFFSET + +#if VMS_DEBUG + _bfd_vms_debug (3, "_bfd_vms_decode_relocs: result = 0\n"); #endif return 0; @@ -1750,6 +2301,20 @@ _bfd_vms_slurp_lnk (bfd * abfd ATTRIBUTE_UNUSED, return 0; } +/* WRITE ETIR SECTION + + This is still under construction and therefore not documented. */ + +static void start_etir_record (bfd *abfd, int index, uquad offset, + bfd_boolean justoffset); +static void start_first_etbt_record (bfd *abfd); +static void start_another_etbt_record (bfd *abfd); +static void sto_imm (bfd *abfd, bfd_size_type, unsigned char *, bfd_vma vaddr, + int index, const char *name); +static void end_etir_record (bfd *abfd); +static void etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, + int checklen); + /* Start ETIR record for section #index at virtual addr offset. */ static void @@ -1780,25 +2345,20 @@ end_etir_record (bfd * abfd) _bfd_vms_output_end (abfd); } -/* WRITE ETIR SECTION - - This is still under construction and therefore not documented. */ +/* Output a STO_IMM command for SSIZE bytes of data from CPR at virtual + address VADDR in section specified by INDEX and NAME. */ static void -sto_imm (bfd * abfd, vms_section *sptr, bfd_vma vaddr, int index) +sto_imm (bfd *abfd, bfd_size_type ssize, unsigned char *cptr, bfd_vma vaddr, + int index, const char *name) { - int size; - int ssize; - unsigned char *cptr; + bfd_size_type size; #if VMS_DEBUG - _bfd_vms_debug (8, "sto_imm %d bytes\n", sptr->size); - _bfd_hexdump (9, sptr->contents, (int) sptr->size, (int) vaddr); + _bfd_vms_debug (8, "sto_imm %d bytes\n", ssize); + _bfd_hexdump (9, cptr, (int) ssize, (int) vaddr); #endif - ssize = sptr->size; - cptr = sptr->contents; - while (ssize > 0) { /* Try all the rest. */ @@ -1808,11 +2368,14 @@ sto_imm (bfd * abfd, vms_section *sptr, bfd_vma vaddr, int index) { /* Doesn't fit, split ! */ end_etir_record (abfd); - start_etir_record (abfd, index, vaddr, FALSE); - /* Get max size. */ - size = _bfd_vms_output_check (abfd, 0); - /* More than what's left ? */ - if (size > ssize) + + if (name [0] && name[1] == 'v' && !strcmp (name, ".vmsdebug")) + start_another_etbt_record (abfd); + else + start_etir_record (abfd, index, vaddr, FALSE); + + size = _bfd_vms_output_check (abfd, 0); /* get max size */ + if (size > ssize) /* more than what's left ? */ size = ssize; } @@ -1827,8 +2390,63 @@ sto_imm (bfd * abfd, vms_section *sptr, bfd_vma vaddr, int index) #endif vaddr += size; - ssize -= size; cptr += size; + ssize -= size; + } +} + +/* Start ETBT record for section #index at virtual addr offset. */ + +static void +start_first_etbt_record (bfd *abfd) +{ + _bfd_vms_output_begin (abfd, EOBJ_S_C_ETBT, -1); + _bfd_vms_output_push (abfd); + + _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1); /* push start offset */ + _bfd_vms_output_long (abfd, (unsigned long) 0); + _bfd_vms_output_flush (abfd); + + _bfd_vms_output_begin (abfd, ETIR_S_C_CTL_DFLOC, -1); /* start = pop() */ + _bfd_vms_output_flush (abfd); +} + +static void +start_another_etbt_record (bfd *abfd) +{ + _bfd_vms_output_begin (abfd, EOBJ_S_C_ETBT, -1); + _bfd_vms_output_push (abfd); +} + +static void +etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, int checklen) +{ + if (_bfd_vms_output_check (abfd, checklen) < 0) + { + end_etir_record (abfd); + if (section->name[0] && section->name[1] == 'v' + && !strcmp (section->name, ".vmsdebug")) + start_another_etbt_record (abfd); + else + start_etir_record (abfd, section->index, vaddr, FALSE); + } +} + +/* Return whether RELOC must be deferred till the end. */ + +static int +defer_reloc_p (arelent *reloc) +{ + switch (reloc->howto->type) + { + case ALPHA_R_NOP: + case ALPHA_R_LDA: + case ALPHA_R_BSR: + case ALPHA_R_BOH: + return 1; + + default: + return 0; } } @@ -1838,8 +2456,6 @@ int _bfd_vms_write_tir (bfd * abfd, int objtype ATTRIBUTE_UNUSED) { asection *section; - vms_section *sptr; - int nextoffset; #if VMS_DEBUG _bfd_vms_debug (2, "vms_write_tir (%p, %d)\n", abfd, objtype); @@ -1847,391 +2463,346 @@ _bfd_vms_write_tir (bfd * abfd, int objtype ATTRIBUTE_UNUSED) _bfd_vms_output_alignment (abfd, 4); - nextoffset = 0; PRIV (vms_linkage_index) = 1; - /* Dump all other sections. */ - section = abfd->sections; - - while (section != NULL) + for (section = abfd->sections; section; section = section->next) { - #if VMS_DEBUG _bfd_vms_debug (4, "writing %d. section '%s' (%d bytes)\n", section->index, section->name, (int) (section->size)); #endif + if (!(section->flags & SEC_HAS_CONTENTS) + || bfd_is_com_section (section)) + continue; + + if (!section->contents) + { + bfd_set_error (bfd_error_no_contents); + return -1; + } + + if (section->name[0] + && section->name[1] == 'v' + && !strcmp (section->name, ".vmsdebug")) + start_first_etbt_record (abfd); + else + start_etir_record (abfd, section->index, 0, FALSE); + if (section->flags & SEC_RELOC) { - int i; + bfd_vma curr_addr = 0; + unsigned char *curr_data = section->contents; + bfd_size_type size; + int pass2_needed = 0; + int pass2_in_progress = 0; + unsigned int irel; + + if (section->reloc_count <= 0) + (*_bfd_error_handler) + (_("SEC_RELOC with no relocs in section %s"), section->name); - if ((i = section->reloc_count) <= 0) - (*_bfd_error_handler) (_("SEC_RELOC with no relocs in section %s"), - section->name); #if VMS_DEBUG else { - arelent **rptr; + int i = section->reloc_count; + arelent **rptr = section->orelocation; _bfd_vms_debug (4, "%d relocations:\n", i); - rptr = section->orelocation; while (i-- > 0) { - _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, addr %08lx, off %08lx, len %d: %s\n", + _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, " + "addr %08lx, off %08lx, len %d: %s\n", (*(*rptr)->sym_ptr_ptr)->name, (*(*rptr)->sym_ptr_ptr)->section->name, (long) (*(*rptr)->sym_ptr_ptr)->value, (*rptr)->address, (*rptr)->addend, bfd_get_reloc_size ((*rptr)->howto), - (*rptr)->howto->name); + ( *rptr)->howto->name); rptr++; } } #endif - } - if ((section->flags & SEC_HAS_CONTENTS) - && (! bfd_is_com_section (section))) - { - /* Virtual addr in section. */ - bfd_vma vaddr; - - sptr = _bfd_get_vms_section (abfd, section->index); - if (sptr == NULL) + new_pass: + for (irel = 0; irel < section->reloc_count; irel++) { - bfd_set_error (bfd_error_no_contents); - return -1; - } + struct evax_private_udata_struct *udata; + arelent *rptr = section->orelocation [irel]; + bfd_vma addr = rptr->address; + asymbol *sym = *rptr->sym_ptr_ptr; + asection *sec = sym->section; + int defer = defer_reloc_p (rptr); + unsigned int slen; + char *hash; + + if (pass2_in_progress) + { + /* Non-deferred relocs have already been output. */ + if (!defer) + continue; + } + else + { + /* Deferred relocs must be output at the very end. */ + if (defer) + { + pass2_needed = 1; + continue; + } - vaddr = (bfd_vma) (sptr->offset); + /* Regular relocs are intertwined with binary data. */ + if (curr_addr > addr) + (*_bfd_error_handler) (_("Size error in section %s"), + section->name); + size = addr - curr_addr; + sto_imm (abfd, size, curr_data, curr_addr, + section->index, section->name); + curr_data += size; + curr_addr += size; + } - start_etir_record (abfd, section->index, (uquad) sptr->offset, - FALSE); + size = bfd_get_reloc_size (rptr->howto); - while (sptr != NULL) - { - /* One STA_PQ, CTL_SETRB per vms_section. */ - if (section->flags & SEC_RELOC) - { - /* Check for relocs. */ - arelent **rptr = section->orelocation; - int i = section->reloc_count; + switch (rptr->howto->type) + { + case ALPHA_R_IGNORE: + break; - for (;;) + case ALPHA_R_REFLONG: + if (bfd_is_und_section (sym->section)) { - bfd_size_type addr = (*rptr)->address; - bfd_size_type len = bfd_get_reloc_size ((*rptr)->howto); - if (sptr->offset < addr) - { - /* Sptr starts before reloc. */ - bfd_size_type before = addr - sptr->offset; - if (sptr->size <= before) - { - /* Complete before. */ - sto_imm (abfd, sptr, vaddr, section->index); - vaddr += sptr->size; - break; - } - else - { - /* Partly before. */ - int after = sptr->size - before; - - sptr->size = before; - sto_imm (abfd, sptr, vaddr, section->index); - vaddr += sptr->size; - sptr->contents += before; - sptr->offset += before; - sptr->size = after; - } - } - else if (sptr->offset == addr) + bfd_vma addend = rptr->addend; + slen = strlen ((char *) sym->name); + hash = _bfd_vms_length_hash_symbol + (abfd, sym->name, EOBJ_S_C_SYMSIZ); + etir_output_check (abfd, section, curr_addr, slen); + if (addend) { - /* Sptr starts at reloc. */ - asymbol *sym = *(*rptr)->sym_ptr_ptr; - asection *sec = sym->section; - - switch ((*rptr)->howto->type) - { - case ALPHA_R_IGNORE: - break; - - case ALPHA_R_REFLONG: - { - if (bfd_is_und_section (sym->section)) - { - int slen = strlen ((char *) sym->name); - char *hash; - - if (_bfd_vms_output_check (abfd, slen) < 0) - { - end_etir_record (abfd); - start_etir_record (abfd, - section->index, - vaddr, FALSE); - } - _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_GBL_LW, - -1); - hash = (_bfd_vms_length_hash_symbol - (abfd, sym->name, EOBJ_S_C_SYMSIZ)); - _bfd_vms_output_counted (abfd, hash); - _bfd_vms_output_flush (abfd); - } - else if (bfd_is_abs_section (sym->section)) - { - if (_bfd_vms_output_check (abfd, 16) < 0) - { - end_etir_record (abfd); - start_etir_record (abfd, - section->index, - vaddr, FALSE); - } - _bfd_vms_output_begin (abfd, - ETIR_S_C_STA_LW, - -1); - _bfd_vms_output_quad (abfd, - (uquad) sym->value); - _bfd_vms_output_flush (abfd); - _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_LW, - -1); - _bfd_vms_output_flush (abfd); - } - else - { - if (_bfd_vms_output_check (abfd, 32) < 0) - { - end_etir_record (abfd); - start_etir_record (abfd, - section->index, - vaddr, FALSE); - } - _bfd_vms_output_begin (abfd, - ETIR_S_C_STA_PQ, - -1); - _bfd_vms_output_long (abfd, - (unsigned long) (sec->index)); - _bfd_vms_output_quad (abfd, - ((uquad) (*rptr)->addend - + (uquad) sym->value)); - _bfd_vms_output_flush (abfd); - _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_LW, - -1); - _bfd_vms_output_flush (abfd); - } - } - break; - - case ALPHA_R_REFQUAD: - { - if (bfd_is_und_section (sym->section)) - { - int slen = strlen ((char *) sym->name); - char *hash; - - if (_bfd_vms_output_check (abfd, slen) < 0) - { - end_etir_record (abfd); - start_etir_record (abfd, - section->index, - vaddr, FALSE); - } - _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_GBL, - -1); - hash = (_bfd_vms_length_hash_symbol - (abfd, sym->name, EOBJ_S_C_SYMSIZ)); - _bfd_vms_output_counted (abfd, hash); - _bfd_vms_output_flush (abfd); - } - else if (bfd_is_abs_section (sym->section)) - { - if (_bfd_vms_output_check (abfd, 16) < 0) - { - end_etir_record (abfd); - start_etir_record (abfd, - section->index, - vaddr, FALSE); - } - _bfd_vms_output_begin (abfd, - ETIR_S_C_STA_QW, - -1); - _bfd_vms_output_quad (abfd, - (uquad) sym->value); - _bfd_vms_output_flush (abfd); - _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_QW, - -1); - _bfd_vms_output_flush (abfd); - } - else - { - if (_bfd_vms_output_check (abfd, 32) < 0) - { - end_etir_record (abfd); - start_etir_record (abfd, - section->index, - vaddr, FALSE); - } - _bfd_vms_output_begin (abfd, - ETIR_S_C_STA_PQ, - -1); - _bfd_vms_output_long (abfd, - (unsigned long) (sec->index)); - _bfd_vms_output_quad (abfd, - ((uquad) (*rptr)->addend - + (uquad) sym->value)); - _bfd_vms_output_flush (abfd); - _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_OFF, - -1); - _bfd_vms_output_flush (abfd); - } - } - break; - - case ALPHA_R_HINT: - { - int hint_size; - char *hash ATTRIBUTE_UNUSED; - - hint_size = sptr->size; - sptr->size = len; - sto_imm (abfd, sptr, vaddr, section->index); - sptr->size = hint_size; - } - break; - case ALPHA_R_LINKAGE: - { - char *hash; - - if (_bfd_vms_output_check (abfd, 64) < 0) - { - end_etir_record (abfd); - start_etir_record (abfd, section->index, - vaddr, FALSE); - } - _bfd_vms_output_begin (abfd, - ETIR_S_C_STC_LP_PSB, - -1); - _bfd_vms_output_long (abfd, - (unsigned long) PRIV (vms_linkage_index)); - PRIV (vms_linkage_index) += 2; - hash = (_bfd_vms_length_hash_symbol - (abfd, sym->name, EOBJ_S_C_SYMSIZ)); - _bfd_vms_output_counted (abfd, hash); - _bfd_vms_output_byte (abfd, 0); - _bfd_vms_output_flush (abfd); - } - break; - - case ALPHA_R_CODEADDR: - { - int slen = strlen ((char *) sym->name); - char *hash; - if (_bfd_vms_output_check (abfd, slen) < 0) - { - end_etir_record (abfd); - start_etir_record (abfd, - section->index, - vaddr, FALSE); - } - _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_CA, - -1); - hash = (_bfd_vms_length_hash_symbol - (abfd, sym->name, EOBJ_S_C_SYMSIZ)); - _bfd_vms_output_counted (abfd, hash); - _bfd_vms_output_flush (abfd); - } - break; - - default: - (*_bfd_error_handler) (_("Unhandled relocation %s"), - (*rptr)->howto->name); - break; - } - - vaddr += len; - - if (len == sptr->size) - { - break; - } - else - { - sptr->contents += len; - sptr->offset += len; - sptr->size -= len; - i--; - rptr++; - } + _bfd_vms_output_begin (abfd, ETIR_S_C_STA_GBL, -1); + _bfd_vms_output_counted (abfd, hash); + _bfd_vms_output_flush (abfd); + _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1); + _bfd_vms_output_long (abfd, (unsigned long) addend); + _bfd_vms_output_flush (abfd); + _bfd_vms_output_begin (abfd, ETIR_S_C_OPR_ADD, -1); + _bfd_vms_output_flush (abfd); + _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1); + _bfd_vms_output_flush (abfd); } else { - /* Sptr starts after reloc. */ - i--; - /* Check next reloc. */ - rptr++; + _bfd_vms_output_begin (abfd, ETIR_S_C_STO_GBL_LW, -1); + _bfd_vms_output_counted (abfd, hash); + _bfd_vms_output_flush (abfd); } + } + else if (bfd_is_abs_section (sym->section)) + { + etir_output_check (abfd, section, curr_addr, 16); + _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1); + _bfd_vms_output_long (abfd, (unsigned long) sym->value); + _bfd_vms_output_flush (abfd); + _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1); + _bfd_vms_output_flush (abfd); + } + else + { + etir_output_check (abfd, section, curr_addr, 32); + _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1); + _bfd_vms_output_long (abfd, (unsigned long) sec->index); + _bfd_vms_output_quad (abfd, (uquad) rptr->addend + + (uquad) sym->value); + _bfd_vms_output_flush (abfd); + /* ??? Table B-8 of the OpenVMS Linker Utilily Manual + says that we should have a ETIR_S_C_STO_OFF here. + But the relocation would not be BFD_RELOC_32 then. + This case is very likely unreachable. */ + _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1); + _bfd_vms_output_flush (abfd); + } + break; - if (i == 0) + case ALPHA_R_REFQUAD: + if (bfd_is_und_section (sym->section)) + { + bfd_vma addend = rptr->addend; + slen = strlen ((char *) sym->name); + hash = _bfd_vms_length_hash_symbol + (abfd, sym->name, EOBJ_S_C_SYMSIZ); + etir_output_check (abfd, section, curr_addr, slen); + if (addend) + { + _bfd_vms_output_begin (abfd, ETIR_S_C_STA_GBL, -1); + _bfd_vms_output_counted (abfd, hash); + _bfd_vms_output_flush (abfd); + _bfd_vms_output_begin (abfd, ETIR_S_C_STA_QW, -1); + _bfd_vms_output_quad (abfd, (uquad) addend); + _bfd_vms_output_flush (abfd); + _bfd_vms_output_begin (abfd, ETIR_S_C_OPR_ADD, -1); + _bfd_vms_output_flush (abfd); + _bfd_vms_output_begin (abfd, ETIR_S_C_STO_QW, -1); + _bfd_vms_output_flush (abfd); + } + else { - /* All reloc checked. */ - if (sptr->size > 0) - { - /* Dump rest. */ - sto_imm (abfd, sptr, vaddr, section->index); - vaddr += sptr->size; - } - break; + _bfd_vms_output_begin (abfd, ETIR_S_C_STO_GBL, -1); + _bfd_vms_output_counted (abfd, hash); + _bfd_vms_output_flush (abfd); } } + else if (bfd_is_abs_section (sym->section)) + { + etir_output_check (abfd, section, curr_addr, 16); + _bfd_vms_output_begin (abfd, ETIR_S_C_STA_QW, -1); + _bfd_vms_output_quad (abfd, (uquad) sym->value); + _bfd_vms_output_flush (abfd); + _bfd_vms_output_begin (abfd, ETIR_S_C_STO_QW, -1); + _bfd_vms_output_flush (abfd); + } + else + { + etir_output_check (abfd, section, curr_addr, 32); + _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1); + _bfd_vms_output_long (abfd, (unsigned long) sec->index); + _bfd_vms_output_quad (abfd, (uquad) rptr->addend + + (uquad) sym->value); + _bfd_vms_output_flush (abfd); + _bfd_vms_output_begin (abfd, ETIR_S_C_STO_OFF, -1); + _bfd_vms_output_flush (abfd); + } + break; + + case ALPHA_R_HINT: + sto_imm (abfd, size, curr_data, curr_addr, + section->index, section->name); + break; + + case ALPHA_R_LINKAGE: + etir_output_check (abfd, section, curr_addr, 64); + _bfd_vms_output_begin (abfd, ETIR_S_C_STC_LP_PSB, -1); + _bfd_vms_output_long + (abfd, (unsigned long) PRIV (vms_linkage_index)); + PRIV (vms_linkage_index) += 2; + hash = _bfd_vms_length_hash_symbol + (abfd, sym->name, EOBJ_S_C_SYMSIZ); + _bfd_vms_output_counted (abfd, hash); + _bfd_vms_output_byte (abfd, 0); + _bfd_vms_output_flush (abfd); + break; + + case ALPHA_R_CODEADDR: + slen = strlen ((char *) sym->name); + hash = _bfd_vms_length_hash_symbol + (abfd, sym->name, EOBJ_S_C_SYMSIZ); + etir_output_check (abfd, section, curr_addr, slen); + _bfd_vms_output_begin (abfd, ETIR_S_C_STO_CA, -1); + _bfd_vms_output_counted (abfd, hash); + _bfd_vms_output_flush (abfd); + break; + + case ALPHA_R_NOP: + udata + = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr; + etir_output_check (abfd, section, curr_addr, + 32 + 1 + strlen (udata->origname)); + _bfd_vms_output_begin (abfd, ETIR_S_C_STC_NOP_GBL, -1); + _bfd_vms_output_long (abfd, (unsigned long) udata->lkindex); + _bfd_vms_output_long + (abfd, (unsigned long) udata->enbsym->section->index); + _bfd_vms_output_quad (abfd, (uquad) rptr->address); + _bfd_vms_output_long (abfd, (unsigned long) 0x47ff041f); + _bfd_vms_output_long + (abfd, (unsigned long) udata->enbsym->section->index); + _bfd_vms_output_quad (abfd, (uquad) rptr->addend); + _bfd_vms_output_counted + (abfd, _bfd_vms_length_hash_symbol + (abfd, udata->origname, EOBJ_S_C_SYMSIZ)); + _bfd_vms_output_flush (abfd); + break; + + case ALPHA_R_BSR: + (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc")); + break; + + case ALPHA_R_LDA: + udata + = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr; + etir_output_check (abfd, section, curr_addr, + 32 + 1 + strlen (udata->origname)); + _bfd_vms_output_begin (abfd, ETIR_S_C_STC_LDA_GBL, -1); + _bfd_vms_output_long + (abfd, (unsigned long) udata->lkindex + 1); + _bfd_vms_output_long + (abfd, (unsigned long) udata->enbsym->section->index); + _bfd_vms_output_quad (abfd, (uquad) rptr->address); + _bfd_vms_output_long (abfd, (unsigned long) 0x237B0000); + _bfd_vms_output_long + (abfd, (unsigned long) udata->bsym->section->index); + _bfd_vms_output_quad (abfd, (uquad) rptr->addend); + _bfd_vms_output_counted + (abfd, _bfd_vms_length_hash_symbol + (abfd, udata->origname, EOBJ_S_C_SYMSIZ)); + _bfd_vms_output_flush (abfd); + break; + + case ALPHA_R_BOH: + udata + = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr; + etir_output_check (abfd, section, curr_addr, + 32 + 1 + strlen (udata->origname)); + _bfd_vms_output_begin (abfd, ETIR_S_C_STC_BOH_GBL, -1); + _bfd_vms_output_long (abfd, (unsigned long) udata->lkindex); + _bfd_vms_output_long + (abfd, (unsigned long) udata->enbsym->section->index); + _bfd_vms_output_quad (abfd, (uquad) rptr->address); + _bfd_vms_output_long (abfd, (unsigned long) 0xD3400000); + _bfd_vms_output_long + (abfd, (unsigned long) udata->enbsym->section->index); + _bfd_vms_output_quad (abfd, (uquad) rptr->addend); + _bfd_vms_output_counted + (abfd, _bfd_vms_length_hash_symbol + (abfd, udata->origname, EOBJ_S_C_SYMSIZ)); + _bfd_vms_output_flush (abfd); + break; + + default: + (*_bfd_error_handler) (_("Unhandled relocation %s"), + rptr->howto->name); + break; } - else + + curr_data += size; + curr_addr += size; + } /* End of relocs loop. */ + + if (!pass2_in_progress) + { + /* Output rest of section. */ + if (curr_addr > section->size) + (*_bfd_error_handler) (_("Size error in section %s"), + section->name); + size = section->size - curr_addr; + sto_imm (abfd, size, curr_data, curr_addr, + section->index, section->name); + curr_data += size; + curr_addr += size; + + if (pass2_needed) { - /* No relocs, just dump. */ - sto_imm (abfd, sptr, vaddr, section->index); - vaddr += sptr->size; + pass2_in_progress = 1; + goto new_pass; } - - sptr = sptr->next; } - - end_etir_record (abfd); } + + else /* (section->flags & SEC_RELOC) */ + sto_imm (abfd, section->size, section->contents, 0, + section->index, section->name); - section = section->next; + end_etir_record (abfd); } _bfd_vms_output_alignment (abfd, 2); return 0; } - -/* Write traceback data for bfd abfd. */ - -int -_bfd_vms_write_tbt (bfd * abfd ATTRIBUTE_UNUSED, - int objtype ATTRIBUTE_UNUSED) -{ -#if VMS_DEBUG - _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype); -#endif - - return 0; -} - -/* Write debug info for bfd abfd. */ - -int -_bfd_vms_write_dbg (bfd * abfd ATTRIBUTE_UNUSED, - int objtype ATTRIBUTE_UNUSED) -{ -#if VMS_DEBUG - _bfd_vms_debug (2, "vms_write_dbg (%p, objtype)\n", abfd, objtype); -#endif - - return 0; -} |