X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fvms-tir.c;h=af79f20b75ddb0fc65a584d5fb0add9ef0c5751d;hb=8857127957668b516c891330b6d56c3dde8f8b32;hp=124b1b39d893bfbfc635831d9e29e9b1d60e1570;hpb=dc9e099fc0eced486ae2b49455c9da113c11f4ff;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/vms-tir.c b/bfd/vms-tir.c index 124b1b39d8..af79f20b75 100644 --- a/bfd/vms-tir.c +++ b/bfd/vms-tir.c @@ -1,6 +1,7 @@ /* vms-tir.c -- BFD back-end for VAX (openVMS/VAX) and EVAX (openVMS/Alpha) files. - Copyright 1996, 1997, 1998, 1999 Free Software Foundation, Inc. + Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007 + Free Software Foundation, Inc. TIR record handling functions ETIR record handling functions @@ -10,20 +11,19 @@ Written by Klaus K"ampf (kkaempf@rmi.de) -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ /* The following type abbreviations are used: @@ -34,460 +34,425 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ qw quadword (8 byte, 64 bit) da data stream */ -#include - -#include "bfd.h" #include "sysdep.h" +#include "bfd.h" #include "bfdlink.h" #include "libbfd.h" - #include "vms.h" - -static void image_set_ptr PARAMS ((bfd *abfd, int psect, uquad offset)); -static void image_inc_ptr PARAMS ((bfd *abfd, uquad offset)); -static void image_dump PARAMS ((bfd *abfd, unsigned char *ptr, int size, int offset)); -static void image_write_b PARAMS ((bfd *abfd, unsigned int value)); -static void image_write_w PARAMS ((bfd *abfd, unsigned int value)); -static void image_write_l PARAMS ((bfd *abfd, unsigned long value)); -static void image_write_q PARAMS ((bfd *abfd, uquad value)); - -/*-----------------------------------------------------------------------------*/ - + static int -check_section (abfd, size) - bfd *abfd; - int size; +check_section (bfd * abfd, int size) { - int offset; + bfd_size_type offset; - offset = PRIV(image_ptr) - PRIV(image_section)->contents; - if ((bfd_size_type) (offset + size) > PRIV(image_section)->_raw_size) + offset = PRIV (image_ptr) - PRIV (image_section)->contents; + if (offset + size > PRIV (image_section)->size) { - PRIV(image_section)->contents = bfd_realloc (PRIV(image_section)->contents, offset + size); - if (PRIV(image_section)->contents == 0) + PRIV (image_section)->contents + = bfd_realloc (PRIV (image_section)->contents, offset + size); + if (PRIV (image_section)->contents == 0) { (*_bfd_error_handler) (_("No Mem !")); return -1; } - PRIV(image_section)->_raw_size = offset + size; - PRIV(image_ptr) = PRIV(image_section)->contents + offset; + PRIV (image_section)->size = offset + size; + PRIV (image_ptr) = PRIV (image_section)->contents + offset; } return 0; } -/* routines to fill sections contents during tir/etir read */ +/* Routines to fill sections contents during tir/etir read. */ -/* Initialize image buffer pointer to be filled */ +/* Initialize image buffer pointer to be filled. */ static void -image_set_ptr (abfd, psect, offset) - bfd *abfd; - int psect; - uquad offset; +image_set_ptr (bfd * abfd, int psect, uquad offset) { #if VMS_DEBUG _bfd_vms_debug (4, "image_set_ptr (%d=%s, %d)\n", - psect, PRIV(sections)[psect]->name, offset); + psect, PRIV (sections)[psect]->name, offset); #endif - PRIV(image_ptr) = PRIV(sections)[psect]->contents + offset; - PRIV(image_section) = PRIV(sections)[psect]; - return; + PRIV (image_ptr) = PRIV (sections)[psect]->contents + offset; + PRIV (image_section) = PRIV (sections)[psect]; } - -/* Increment image buffer pointer by offset */ +/* Increment image buffer pointer by offset. */ static void -image_inc_ptr (abfd, offset) - bfd *abfd; - uquad offset; +image_inc_ptr (bfd * abfd, uquad offset) { #if VMS_DEBUG _bfd_vms_debug (4, "image_inc_ptr (%d)\n", offset); #endif - PRIV(image_ptr) += offset; - - return; + PRIV (image_ptr) += offset; } - -/* Dump multiple bytes to section image */ +/* Dump multiple bytes to section image. */ static void -image_dump (abfd, ptr, size, offset) - bfd *abfd; - unsigned char *ptr; - int size; - int offset ATTRIBUTE_UNUSED; +image_dump (bfd * abfd, + unsigned char *ptr, + int size, + int offset ATTRIBUTE_UNUSED) { #if VMS_DEBUG - _bfd_vms_debug (8, "image_dump from (%p, %d) to (%p)\n", ptr, size, PRIV(image_ptr)); + _bfd_vms_debug (8, "image_dump from (%p, %d) to (%p)\n", ptr, size, + PRIV (image_ptr)); _bfd_hexdump (9, ptr, size, offset); #endif - if (PRIV(is_vax) && check_section (abfd, size)) + if (PRIV (is_vax) && check_section (abfd, size)) return; while (size-- > 0) - *PRIV(image_ptr)++ = *ptr++; - return; + *PRIV (image_ptr)++ = *ptr++; } - -/* Write byte to section image */ +/* Write byte to section image. */ static void -image_write_b (abfd, value) - bfd *abfd; - unsigned int value; +image_write_b (bfd * abfd, unsigned int value) { #if VMS_DEBUG - _bfd_vms_debug (6, "image_write_b(%02x)\n", (int)value); + _bfd_vms_debug (6, "image_write_b (%02x)\n", (int) value); #endif - if (PRIV(is_vax) && check_section (abfd, 1)) + if (PRIV (is_vax) && check_section (abfd, 1)) return; - *PRIV(image_ptr)++ = (value & 0xff); - return; + *PRIV (image_ptr)++ = (value & 0xff); } - -/* Write 2-byte word to image */ +/* Write 2-byte word to image. */ static void -image_write_w (abfd, value) - bfd *abfd; - unsigned int value; +image_write_w (bfd * abfd, unsigned int value) { #if VMS_DEBUG - _bfd_vms_debug (6, "image_write_w(%04x)\n", (int)value); + _bfd_vms_debug (6, "image_write_w (%04x)\n", (int) value); #endif - if (PRIV(is_vax) && check_section (abfd, 2)) + if (PRIV (is_vax) && check_section (abfd, 2)) return; - bfd_putl16 (value, PRIV(image_ptr)); - PRIV(image_ptr) += 2; - - return; + bfd_putl16 ((bfd_vma) value, PRIV (image_ptr)); + PRIV (image_ptr) += 2; } - -/* Write 4-byte long to image */ +/* Write 4-byte long to image. */ static void -image_write_l (abfd, value) - bfd *abfd; - unsigned long value; +image_write_l (bfd * abfd, unsigned long value) { #if VMS_DEBUG _bfd_vms_debug (6, "image_write_l (%08lx)\n", value); #endif - if (PRIV(is_vax) && check_section (abfd, 4)) + if (PRIV (is_vax) && check_section (abfd, 4)) return; - bfd_putl32 (value, PRIV(image_ptr)); - PRIV(image_ptr) += 4; - - return; + bfd_putl32 ((bfd_vma) value, PRIV (image_ptr)); + PRIV (image_ptr) += 4; } - -/* Write 8-byte quad to image */ +/* Write 8-byte quad to image. */ static void -image_write_q (abfd, value) - bfd *abfd; - uquad value; +image_write_q (bfd * abfd, uquad value) { #if VMS_DEBUG _bfd_vms_debug (6, "image_write_q (%016lx)\n", value); #endif - if (PRIV(is_vax) && check_section (abfd, 8)) + if (PRIV (is_vax) && check_section (abfd, 8)) return; - bfd_putl64 (value, PRIV(image_ptr)); - PRIV(image_ptr) += 8; - - return; + bfd_putl64 (value, PRIV (image_ptr)); + PRIV (image_ptr) += 8; } +static const char * +cmd_name (int cmd) +{ + switch (cmd) + { + case ETIR_S_C_STA_GBL: return "ETIR_S_C_STA_GBL"; + 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"; + case ETIR_S_C_STA_CKARG: return "ETIR_S_C_STA_CKARG"; + case ETIR_S_C_STO_B: return "ETIR_S_C_STO_B"; + case ETIR_S_C_STO_W: return "ETIR_S_C_STO_W"; + case ETIR_S_C_STO_GBL: return "ETIR_S_C_STO_GBL"; + 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_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_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"; + case ETIR_S_C_OPR_REDEF: return "ETIR_S_C_OPR_REDEF"; + case ETIR_S_C_OPR_DFLIT: return "ETIR_S_C_OPR_DFLIT"; + case ETIR_S_C_STC_LP: return "ETIR_S_C_STC_LP"; + case ETIR_S_C_STC_GBL: return "ETIR_S_C_STC_GBL"; + case ETIR_S_C_STC_GCA: return "ETIR_S_C_STC_GCA"; + case ETIR_S_C_STC_PS: return "ETIR_S_C_STC_PS"; + case ETIR_S_C_STC_NBH_PS: return "ETIR_S_C_STC_NBH_PS"; + case ETIR_S_C_STC_NOP_GBL: return "ETIR_S_C_STC_NOP_GBL"; + case ETIR_S_C_STC_NOP_PS: return "ETIR_S_C_STC_NOP_PS"; + case ETIR_S_C_STC_BSR_GBL: return "ETIR_S_C_STC_BSR_GBL"; + case ETIR_S_C_STC_BSR_PS: return "ETIR_S_C_STC_BSR_PS"; + case ETIR_S_C_STC_LDA_GBL: return "ETIR_S_C_STC_LDA_GBL"; + case ETIR_S_C_STC_LDA_PS: return "ETIR_S_C_STC_LDA_PS"; + 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"; + default: + /* These names have not yet been added to this switch statement. */ + abort (); + } +} #define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L) /* etir_sta - + vms stack commands - + handle sta_xxx commands in etir section ptr points to data area in record - - see table B-8 of the openVMS linker manual */ - -static boolean -etir_sta (abfd, cmd, ptr) - bfd *abfd; - int cmd; - unsigned char *ptr; -{ + see table B-8 of the openVMS linker manual. */ + +static bfd_boolean +etir_sta (bfd * abfd, int cmd, unsigned char *ptr) +{ #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, (int) ptr); #endif switch (cmd) { - /* stack */ - /* stack global - arg: cs symbol name + arg: cs symbol name - stack 32 bit value of symbol (high bits set to 0) */ - - case ETIR_S_C_STA_GBL: - { - char *name; - vms_symbol_entry *entry; + stack 32 bit value of symbol (high bits set to 0). */ + case ETIR_S_C_STA_GBL: + { + char *name; + vms_symbol_entry *entry; - name = _bfd_vms_save_counted_string (ptr); - entry = (vms_symbol_entry *) - bfd_hash_lookup (PRIV(vms_symbol_table), name, false, false); - if (entry == (vms_symbol_entry *)NULL) - { + name = _bfd_vms_save_counted_string (ptr); + entry = (vms_symbol_entry *) + bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE); + if (entry == NULL) + { #if VMS_DEBUG - _bfd_vms_debug (3, "ETIR_S_C_STA_GBL: no symbol \"%s\"\n", name); + _bfd_vms_debug (3, "%s: no symbol \"%s\"\n", + cmd_name (cmd), name); #endif - _bfd_vms_push (abfd, (uquad)0, -1); - } - else - { - _bfd_vms_push (abfd, (uquad)(entry->symbol->value), -1); - } - } + _bfd_vms_push (abfd, (uquad) 0, -1); + } + else + _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1); + } break; - /* stack longword - arg: lw value - - stack 32 bit value, sign extend to 64 bit */ + /* stack longword + arg: lw value - case ETIR_S_C_STA_LW: - _bfd_vms_push (abfd, (uquad)bfd_getl32 (ptr), -1); + stack 32 bit value, sign extend to 64 bit. */ + case ETIR_S_C_STA_LW: + _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1); break; - /* stack global - arg: qw value - - stack 64 bit value of symbol */ + /* stack global + arg: qw value - case ETIR_S_C_STA_QW: - _bfd_vms_push (abfd, (uquad)bfd_getl64(ptr), -1); + stack 64 bit value of symbol. */ + case ETIR_S_C_STA_QW: + _bfd_vms_push (abfd, (uquad) bfd_getl64 (ptr), -1); break; - /* stack psect base plus quadword offset - arg: lw section index - qw signed quadword offset (low 32 bits) - - stack qw argument and section index - (see ETIR_S_C_STO_OFF, ETIR_S_C_CTL_SETRB) */ + /* stack psect base plus quadword offset + arg: lw section index + qw signed quadword offset (low 32 bits) - case ETIR_S_C_STA_PQ: - { - uquad dummy; - unsigned int psect; + 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; - psect = bfd_getl32 (ptr); - if (psect >= PRIV(section_count)) - { - (*_bfd_error_handler) (_("Bad section index in ETIR_S_C_STA_PQ")); - bfd_set_error (bfd_error_bad_value); - return false; - } - dummy = bfd_getl64 (ptr+4); - _bfd_vms_push (abfd, dummy, psect); - } + psect = bfd_getl32 (ptr); + if (psect >= PRIV (section_count)) + { + (*_bfd_error_handler) (_("bad section index in %s"), + cmd_name (cmd)); + bfd_set_error (bfd_error_bad_value); + return FALSE; + } + dummy = bfd_getl64 (ptr + 4); + _bfd_vms_push (abfd, dummy, (int) psect); + } break; - /* all not supported */ - - case ETIR_S_C_STA_LI: - case ETIR_S_C_STA_MOD: - case ETIR_S_C_STA_CKARG: - - (*_bfd_error_handler) (_("Unsupported STA cmd %d"), cmd); - return false; + 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)); + return FALSE; break; - default: - (*_bfd_error_handler) (_("Reserved STA cmd %d"), cmd); - return false; + default: + (*_bfd_error_handler) (_("reserved STA cmd %d"), cmd); + return FALSE; break; } #if VMS_DEBUG _bfd_vms_debug (5, "etir_sta true\n"); #endif - return true; + return TRUE; } +/* etir_sto -/* - etir_sto - vms store commands - + handle sto_xxx commands in etir section ptr points to data area in record - - see table B-9 of the openVMS linker manual */ - -static boolean -etir_sto (abfd, cmd, ptr) - 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) { 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, (int) ptr); #endif switch (cmd) { - - /* store byte: pop stack, write byte - arg: - */ - + /* Store byte: pop stack, write byte + arg: -. */ case ETIR_S_C_STO_B: dummy = _bfd_vms_pop (abfd, &psect); -#if 0 - if (is_share) /* FIXME */ - (*_bfd_error_handler) ("ETIR_S_C_STO_B: byte fixups not supported"); -#endif - image_write_b (abfd, dummy & 0xff); /* FIXME: check top bits */ + /* FIXME: check top bits. */ + image_write_b (abfd, (unsigned int) dummy & 0xff); break; - /* store word: pop stack, write word - arg: - */ - + /* Store word: pop stack, write word + arg: -. */ case ETIR_S_C_STO_W: dummy = _bfd_vms_pop (abfd, &psect); -#if 0 - if (is_share) /* FIXME */ - (*_bfd_error_handler) ("ETIR_S_C_STO_B: word fixups not supported"); -#endif - image_write_w (abfd, dummy & 0xffff); /* FIXME: check top bits */ + /* FIXME: check top bits */ + image_write_w (abfd, (unsigned int) dummy & 0xffff); break; - /* store longword: pop stack, write longword - arg: - */ - + /* Store longword: pop stack, write longword + arg: -. */ case ETIR_S_C_STO_LW: dummy = _bfd_vms_pop (abfd, &psect); - dummy += (PRIV(sections)[psect])->vma; - image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */ + dummy += (PRIV (sections)[psect])->vma; + /* FIXME: check top bits. */ + image_write_l (abfd, (unsigned int) dummy & 0xffffffff); break; - /* store quadword: pop stack, write quadword - arg: - */ - + /* Store quadword: pop stack, write quadword + arg: -. */ case ETIR_S_C_STO_QW: dummy = _bfd_vms_pop (abfd, &psect); - dummy += (PRIV(sections)[psect])->vma; - image_write_q (abfd, dummy); /* FIXME: check top bits */ + dummy += (PRIV (sections)[psect])->vma; + /* FIXME: check top bits. */ + image_write_q (abfd, dummy); break; - /* store immediate repeated: pop stack for repeat count + /* Store immediate repeated: pop stack for repeat count arg: lw byte count - da data */ - + da data. */ case ETIR_S_C_STO_IMMR: { - unsigned long size; + int size; size = bfd_getl32 (ptr); - dummy = (unsigned long)_bfd_vms_pop (abfd, NULL); - while (dummy-- > 0L) + dummy = (unsigned long) _bfd_vms_pop (abfd, NULL); + while (dummy-- > 0) image_dump (abfd, ptr+4, size, 0); } break; - /* store global: write symbol value - arg: cs global symbol name */ - + /* Store global: write symbol value + arg: cs global symbol name. */ case ETIR_S_C_STO_GBL: { vms_symbol_entry *entry; char *name; name = _bfd_vms_save_counted_string (ptr); - entry = (vms_symbol_entry *)bfd_hash_lookup (PRIV(vms_symbol_table), name, false, false); - if (entry == (vms_symbol_entry *)NULL) + entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table), + name, FALSE, FALSE); + if (entry == NULL) { - (*_bfd_error_handler) (_("ETIR_S_C_STO_GBL: no symbol \"%s\""), - name); - return false; + (*_bfd_error_handler) (_("%s: no symbol \"%s\""), + cmd_name (cmd), name); + return FALSE; } else - image_write_q (abfd, (uquad)(entry->symbol->value)); /* FIXME, reloc */ + /* FIXME, reloc. */ + image_write_q (abfd, (uquad) (entry->symbol->value)); } break; - /* store code address: write address of entry point - arg: cs global symbol name (procedure) */ - + /* Store code address: write address of entry point + arg: cs global symbol name (procedure). */ case ETIR_S_C_STO_CA: { vms_symbol_entry *entry; char *name; name = _bfd_vms_save_counted_string (ptr); - entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV(vms_symbol_table), name, false, false); - if (entry == (vms_symbol_entry *)NULL) + entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table), + name, FALSE, FALSE); + if (entry == NULL) { - (*_bfd_error_handler) (_("ETIR_S_C_STO_CA: no symbol \"%s\""), - name); - return false; + (*_bfd_error_handler) (_("%s: no symbol \"%s\""), + cmd_name (cmd), name); + return FALSE; } else - image_write_q (abfd, (uquad)(entry->symbol->value)); /* FIXME, reloc */ + /* FIXME, reloc. */ + image_write_q (abfd, (uquad) (entry->symbol->value)); } break; - /* not supported */ - - case ETIR_S_C_STO_RB: - case ETIR_S_C_STO_AB: - (*_bfd_error_handler) (_("ETIR_S_C_STO_RB/AB: Not supported")); - break; - - /* store offset to psect: pop stack, add low 32 bits to base of psect - arg: - */ - + /* Store offset to psect: pop stack, add low 32 bits to base of psect + arg: none. */ case ETIR_S_C_STO_OFF: { uquad q; - int psect; + int psect1; - q = _bfd_vms_pop (abfd, &psect); - q += (PRIV(sections)[psect])->vma; + q = _bfd_vms_pop (abfd, & psect1); + q += (PRIV (sections)[psect1])->vma; image_write_q (abfd, q); } break; - /* store immediate + /* Store immediate arg: lw count of bytes - da data */ - + da data. */ case ETIR_S_C_STO_IMM: { int size; @@ -497,492 +462,402 @@ etir_sto (abfd, cmd, ptr) } break; - /* this code is 'reserved to digital' according to the openVMS linker manual, - however it is generated by the DEC C compiler and defined in the include file. + /* This code is 'reserved to digital' according to the openVMS + linker manual, however it is generated by the DEC C compiler + and defined in the include file. FIXME, since the following is just a guess store global longword: store 32bit value of symbol - arg: cs symbol name */ - + arg: cs symbol name. */ case ETIR_S_C_STO_GBL_LW: { vms_symbol_entry *entry; char *name; name = _bfd_vms_save_counted_string (ptr); - entry = (vms_symbol_entry *)bfd_hash_lookup (PRIV(vms_symbol_table), name, false, false); - if (entry == (vms_symbol_entry *)NULL) + entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table), + name, FALSE, FALSE); + if (entry == NULL) { #if VMS_DEBUG - _bfd_vms_debug (3, "ETIR_S_C_STO_GBL_LW: no symbol \"%s\"\n", name); + _bfd_vms_debug (3, "%s: no symbol \"%s\"\n", cmd_name (cmd), name); #endif - image_write_l (abfd, (unsigned long)0); /* FIXME, reloc */ + image_write_l (abfd, (unsigned long) 0); /* FIXME, reloc */ } else - image_write_l (abfd, (unsigned long)(entry->symbol->value)); /* FIXME, reloc */ + /* FIXME, reloc. */ + image_write_l (abfd, (unsigned long) (entry->symbol->value)); } break; - /* not supported */ - + case ETIR_S_C_STO_RB: + case ETIR_S_C_STO_AB: case ETIR_S_C_STO_LP_PSB: - (*_bfd_error_handler) (_("ETIR_S_C_STO_LP_PSB: Not supported")); + (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd)); break; - /* */ - case ETIR_S_C_STO_HINT_GBL: - (*_bfd_error_handler) (_("ETIR_S_C_STO_HINT_GBL: not implemented")); - break; - - /* */ - case ETIR_S_C_STO_HINT_PS: - (*_bfd_error_handler) (_("ETIR_S_C_STO_HINT_PS: not implemented")); + (*_bfd_error_handler) (_("%s: not implemented"), cmd_name (cmd)); break; default: - (*_bfd_error_handler) (_("Reserved STO cmd %d"), cmd); + (*_bfd_error_handler) (_("reserved STO cmd %d"), cmd); break; } - return true; + return TRUE; } -/* stack operator commands +/* Stack operator commands all 32 bit signed arithmetic all word just like a stack calculator arguments are popped from stack, results are pushed on stack - - see table B-10 of the openVMS linker manual */ - -static boolean -etir_opr (abfd, cmd, ptr) - bfd *abfd; - int cmd; - unsigned char *ptr ATTRIBUTE_UNUSED; + + see table B-10 of the openVMS linker manual. */ + +static bfd_boolean +etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED) { 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, (int) ptr); #endif switch (cmd) { - /* operation */ - - /* no-op */ - - case ETIR_S_C_OPR_NOP: + case ETIR_S_C_OPR_NOP: /* No-op. */ break; - /* add */ - - case ETIR_S_C_OPR_ADD: - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (uquad)(op1 + op2), -1); + case ETIR_S_C_OPR_ADD: /* Add. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 + op2), -1); break; - /* subtract */ - - case ETIR_S_C_OPR_SUB: - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (uquad)(op2 - op1), -1); + case ETIR_S_C_OPR_SUB: /* Subtract. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op2 - op1), -1); break; - /* multiply */ - - case ETIR_S_C_OPR_MUL: - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (uquad)(op1 * op2), -1); + case ETIR_S_C_OPR_MUL: /* Multiply. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 * op2), -1); break; - /* divide */ - - case ETIR_S_C_OPR_DIV: - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); + case ETIR_S_C_OPR_DIV: /* Divide. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); if (op2 == 0) - _bfd_vms_push (abfd, (uquad)0L, -1); + _bfd_vms_push (abfd, (uquad) 0, -1); else - _bfd_vms_push (abfd, (uquad)(op2 / op1), -1); + _bfd_vms_push (abfd, (uquad) (op2 / op1), -1); break; - /* logical and */ - - case ETIR_S_C_OPR_AND: - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (uquad)(op1 & op2), -1); + case ETIR_S_C_OPR_AND: /* Logical AND. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 & op2), -1); break; - /* logical inclusive or */ - - case ETIR_S_C_OPR_IOR: - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (uquad)(op1 | op2), -1); + case ETIR_S_C_OPR_IOR: /* Logical inclusive OR. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 | op2), -1); break; - /* logical exclusive or */ - - case ETIR_S_C_OPR_EOR: - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (uquad)(op1 ^ op2), -1); - break; - - /* negate */ - - case ETIR_S_C_OPR_NEG: - op1 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (uquad)(-op1), -1); + case ETIR_S_C_OPR_EOR: /* Logical exclusive OR. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 ^ op2), -1); break; - /* complement */ - - case ETIR_S_C_OPR_COM: - op1 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (uquad)(op1 ^ -1L), -1); + case ETIR_S_C_OPR_NEG: /* Negate. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (-op1), -1); break; - /* insert field */ - - case ETIR_S_C_OPR_INSV: - (void)_bfd_vms_pop (abfd, NULL); - (*_bfd_error_handler) (_("ETIR_S_C_OPR_INSV: Not supported")); + case ETIR_S_C_OPR_COM: /* Complement. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 ^ -1L), -1); break; - /* arithmetic shift */ - - case ETIR_S_C_OPR_ASH: - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - if (op2 < 0) /* shift right */ + case ETIR_S_C_OPR_ASH: /* Arithmetic shift. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + if (op2 < 0) /* Shift right. */ op1 >>= -op2; - else /* shift left */ + else /* Shift left. */ op1 <<= op2; - _bfd_vms_push (abfd, (uquad)op1, -1); + _bfd_vms_push (abfd, (uquad) op1, -1); break; - /* unsigned shift */ - - case ETIR_S_C_OPR_USH: - (*_bfd_error_handler) (_("ETIR_S_C_OPR_USH: Not supported")); + case ETIR_S_C_OPR_INSV: /* Insert field. */ + (void) _bfd_vms_pop (abfd, NULL); + case ETIR_S_C_OPR_USH: /* Unsigned shift. */ + case ETIR_S_C_OPR_ROT: /* Rotate. */ + 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; - /* rotate */ - - case ETIR_S_C_OPR_ROT: - (*_bfd_error_handler) (_("ETIR_S_C_OPR_ROT: Not supported")); - break; - - /* select */ - - case ETIR_S_C_OPR_SEL: - if ((long)_bfd_vms_pop (abfd, NULL) & 0x01L) - (void)_bfd_vms_pop (abfd, NULL); + case ETIR_S_C_OPR_SEL: /* Select. */ + if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L) + (void) _bfd_vms_pop (abfd, NULL); else { - op1 = (long)_bfd_vms_pop (abfd, NULL); - (void)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (uquad)op1, -1); + op1 = (long) _bfd_vms_pop (abfd, NULL); + (void) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) op1, -1); } break; - /* redefine symbol to current location */ - - case ETIR_S_C_OPR_REDEF: - (*_bfd_error_handler) (_("ETIR_S_C_OPR_REDEF: Not supported")); - break; - - /* define a literal */ - - case ETIR_S_C_OPR_DFLIT: - (*_bfd_error_handler) (_("ETIR_S_C_OPR_DFLIT: Not supported")); - break; - default: - (*_bfd_error_handler) (_("Reserved OPR cmd %d"), cmd); + (*_bfd_error_handler) (_("reserved OPR cmd %d"), cmd); break; } - return true; + return TRUE; } +/* Control commands. -/* control commands - - see table B-11 of the openVMS linker manual */ + See table B-11 of the openVMS linker manual. */ -static boolean -etir_ctl (abfd, cmd, ptr) - bfd *abfd; - int cmd; - unsigned char *ptr; +static bfd_boolean +etir_ctl (bfd * abfd, int cmd, unsigned char *ptr) { 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, (int) ptr); #endif switch (cmd) { - /* set relocation base: pop stack, set image location counter - arg: - */ - + /* Det relocation base: pop stack, set image location counter + arg: none. */ case ETIR_S_C_CTL_SETRB: dummy = _bfd_vms_pop (abfd, &psect); image_set_ptr (abfd, psect, dummy); break; - /* augment relocation base: increment image location counter by offset - arg: lw offset value */ - + /* Augment relocation base: increment image location counter by offset + arg: lw offset value. */ case ETIR_S_C_CTL_AUGRB: dummy = bfd_getl32 (ptr); image_inc_ptr (abfd, dummy); break; - /* define location: pop index, save location counter under index - arg: - */ - + /* Define location: pop index, save location counter under index + arg: none. */ case ETIR_S_C_CTL_DFLOC: dummy = _bfd_vms_pop (abfd, NULL); /* FIXME */ break; - /* set location: pop index, restore location counter from index - arg: - */ - + /* Set location: pop index, restore location counter from index + arg: none. */ case ETIR_S_C_CTL_STLOC: dummy = _bfd_vms_pop (abfd, &psect); /* FIXME */ break; - /* stack defined location: pop index, push location counter from index - arg: - */ - + /* 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 */ + /* FIXME. */ break; default: - (*_bfd_error_handler) (_("Reserved CTL cmd %d"), cmd); + (*_bfd_error_handler) (_("reserved CTL cmd %d"), cmd); break; } - return true; + return TRUE; } +/* Store conditional commands -/* store conditional commands - - see table B-12 and B-13 of the openVMS linker manual */ + See table B-12 and B-13 of the openVMS linker manual. */ -static boolean -etir_stc (abfd, cmd, ptr) - bfd *abfd; - int cmd; - unsigned char *ptr ATTRIBUTE_UNUSED; +static bfd_boolean +etir_stc (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED) { - #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, (int) ptr); #endif switch (cmd) { /* 200 Store-conditional Linkage Pair - arg: */ - + arg: none. */ case ETIR_S_C_STC_LP: - (*_bfd_error_handler) (_("ETIR_S_C_STC_LP: not supported")); + (*_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 */ - + cs procedure name + by signature length + da signature. */ case ETIR_S_C_STC_LP_PSB: - image_inc_ptr (abfd, 16); /* skip entry,procval */ + image_inc_ptr (abfd, (uquad) 16); /* skip entry,procval */ break; /* 202 Store-conditional Address at global address arg: lw linkage index - cs global name */ + cs global name. */ case ETIR_S_C_STC_GBL: - (*_bfd_error_handler) (_("ETIR_S_C_STC_GBL: not supported")); + (*_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 */ - + cs procedure name. */ case ETIR_S_C_STC_GCA: - (*_bfd_error_handler) (_("ETIR_S_C_STC_GCA: not supported")); + (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd)); break; /* 204 Store-conditional Address at psect + offset arg: lw linkage index - lw psect index - qw offset */ - + lw psect index + qw offset. */ case ETIR_S_C_STC_PS: - (*_bfd_error_handler) (_("ETIR_S_C_STC_PS: not supported")); + (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd)); break; /* 205 Store-conditional NOP at address of global - arg: */ - + arg: none. */ case ETIR_S_C_STC_NOP_GBL: /* 206 Store-conditional NOP at pect + offset - arg: */ - + arg: none. */ case ETIR_S_C_STC_NOP_PS: /* 207 Store-conditional BSR at global address - arg: */ - + arg: none. */ case ETIR_S_C_STC_BSR_GBL: /* 208 Store-conditional BSR at pect + offset - arg: */ - + arg: none. */ case ETIR_S_C_STC_BSR_PS: /* 209 Store-conditional LDA at global address - arg: */ - + arg: none. */ case ETIR_S_C_STC_LDA_GBL: /* 210 Store-conditional LDA at psect + offset - arg: */ - + arg: none. */ case ETIR_S_C_STC_LDA_PS: /* 211 Store-conditional BSR or Hint at global address - arg: */ - + arg: none. */ case ETIR_S_C_STC_BOH_GBL: /* 212 Store-conditional BSR or Hint at pect + offset - arg: */ - + arg: none. */ case ETIR_S_C_STC_BOH_PS: /* 213 Store-conditional NOP,BSR or HINT at global address - arg: */ - + arg: none. */ case ETIR_S_C_STC_NBH_GBL: /* 214 Store-conditional NOP,BSR or HINT at psect + offset - arg: */ - + arg: none. */ case ETIR_S_C_STC_NBH_PS: -/* FIXME (*_bfd_error_handler) ("ETIR_S_C_STC_xx: (%d) not supported", cmd); */ + /* FIXME */ break; default: #if VMS_DEBUG - _bfd_vms_debug (3, "Reserved STC cmd %d", cmd); + _bfd_vms_debug (3, "reserved STC cmd %d", cmd); #endif break; } - return true; + return TRUE; } - static asection * -new_section (abfd, idx) - bfd *abfd ATTRIBUTE_UNUSED; - int idx; +new_section (bfd * abfd ATTRIBUTE_UNUSED, int idx) { asection *section; char sname[16]; char *name; #if VMS_DEBUG - _bfd_vms_debug (5, "new_section %d\n", idx); + _bfd_vms_debug (5, "new_section %d\n", idx); #endif sprintf (sname, SECTION_NAME_TEMPLATE, idx); - name = bfd_malloc (strlen (sname) + 1); + name = bfd_malloc ((bfd_size_type) strlen (sname) + 1); if (name == 0) - return 0; + return NULL; strcpy (name, sname); - section = bfd_malloc (sizeof (asection)); + section = bfd_malloc ((bfd_size_type) sizeof (asection)); if (section == 0) { #if VMS_DEBUG _bfd_vms_debug (6, "bfd_make_section (%s) failed", name); #endif - return 0; + return NULL; } - section->_raw_size = 0; + section->size = 0; section->vma = 0; section->contents = 0; - section->_cooked_size = 0; section->name = name; section->index = idx; return section; } - static int -alloc_section (abfd, idx) - bfd *abfd; - unsigned int idx; +alloc_section (bfd * abfd, unsigned int idx) { + bfd_size_type amt; + #if VMS_DEBUG - _bfd_vms_debug (4, "alloc_section %d\n", idx); + _bfd_vms_debug (4, "alloc_section %d\n", idx); #endif - PRIV(sections) = ((asection **) - bfd_realloc (PRIV(sections), (idx+1) * sizeof (asection *))); - if (PRIV(sections) == 0) + amt = idx + 1; + amt *= sizeof (asection *); + PRIV (sections) = bfd_realloc (PRIV (sections), amt); + if (PRIV (sections) == 0) return -1; - while (PRIV(section_count) <= idx) + while (PRIV (section_count) <= idx) { - PRIV(sections)[PRIV(section_count)] = new_section (abfd, PRIV(section_count)); - if (PRIV(sections)[PRIV(section_count)] == 0) + PRIV (sections)[PRIV (section_count)] + = new_section (abfd, (int) PRIV (section_count)); + if (PRIV (sections)[PRIV (section_count)] == 0) return -1; - PRIV(section_count)++; + PRIV (section_count)++; } return 0; } +/* tir_sta -/* - * tir_sta - * - * vax stack commands - * - * handle sta_xxx commands in tir section - * ptr points to data area in record - * - * see table 7-3 of the VAX/VMS linker manual - */ + vax stack commands + + Handle sta_xxx commands in tir section + ptr points to data area in record + + See table 7-3 of the VAX/VMS linker manual. */ static unsigned char * -tir_sta (bfd *abfd, unsigned char *ptr) +tir_sta (bfd * abfd, unsigned char *ptr) { int cmd = *ptr++; @@ -992,320 +867,303 @@ tir_sta (bfd *abfd, unsigned char *ptr) switch (cmd) { - /* stack */ - case TIR_S_C_STA_GBL: - /* - * stack global - * arg: cs symbol name - * - * stack 32 bit value of symbol (high bits set to 0) - */ - { - char *name; - vms_symbol_entry *entry; + /* stack */ + case TIR_S_C_STA_GBL: + /* stack global + arg: cs symbol name - name = _bfd_vms_save_counted_string (ptr); + stack 32 bit value of symbol (high bits set to 0). */ + { + char *name; + vms_symbol_entry *entry; - entry = _bfd_vms_enter_symbol (abfd, name); - if (entry == (vms_symbol_entry *)NULL) - return 0; + name = _bfd_vms_save_counted_string (ptr); - _bfd_vms_push (abfd, (unsigned long)(entry->symbol->value), -1); - ptr += *ptr + 1; - } + entry = _bfd_vms_enter_symbol (abfd, name); + if (entry == NULL) + return NULL; + + _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1); + ptr += *ptr + 1; + } break; - case TIR_S_C_STA_SB: - /* - * stack signed byte - * arg: by value - * - * stack byte value, sign extend to 32 bit - */ - _bfd_vms_push (abfd, (long)*ptr++, -1); - break; - - case TIR_S_C_STA_SW: - /* - * stack signed short word - * arg: sh value - * - * stack 16 bit value, sign extend to 32 bit - */ - _bfd_vms_push (abfd, (long)bfd_getl16(ptr), -1); - ptr += 2; + case TIR_S_C_STA_SB: + /* stack signed byte + arg: by value + + stack byte value, sign extend to 32 bit. */ + _bfd_vms_push (abfd, (uquad) *ptr++, -1); break; - case TIR_S_C_STA_LW: - /* - * stack signed longword - * arg: lw value - * - * stack 32 bit value - */ - _bfd_vms_push (abfd, (long)bfd_getl32 (ptr), -1); - ptr += 4; - break; - - case TIR_S_C_STA_PB: - case TIR_S_C_STA_WPB: - /* - * stack psect base plus byte offset (word index) - * arg: by section index - * (sh section index) - * by signed byte offset - * - */ - { - unsigned long dummy; - unsigned int psect; - - if (cmd == TIR_S_C_STA_PB) - psect = *ptr++; - else - { - psect = bfd_getl16(ptr); - ptr += 2; - } + case TIR_S_C_STA_SW: + /* stack signed short word + arg: sh value - if (psect >= PRIV(section_count)) - { - alloc_section (abfd, psect); - } + stack 16 bit value, sign extend to 32 bit. */ + _bfd_vms_push (abfd, (uquad) bfd_getl16 (ptr), -1); + ptr += 2; + break; - dummy = (long)*ptr++; - dummy += (PRIV(sections)[psect])->vma; - _bfd_vms_push (abfd, dummy, psect); - } - break; - - case TIR_S_C_STA_PW: - case TIR_S_C_STA_WPW: - /* - * stack psect base plus word offset (word index) - * arg: by section index - * (sh section index) - * sh signed short offset - * - */ - { - unsigned long dummy; - unsigned int psect; - - if (cmd == TIR_S_C_STA_PW) - psect = *ptr++; - else - { - psect = bfd_getl16(ptr); - ptr += 2; - } + case TIR_S_C_STA_LW: + /* stack signed longword + arg: lw value - if (psect >= PRIV(section_count)) - { - alloc_section (abfd, psect); - } + stack 32 bit value. */ + _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1); + ptr += 4; + break; - dummy = bfd_getl16(ptr); ptr+=2; - dummy += (PRIV(sections)[psect])->vma; - _bfd_vms_push (abfd, dummy, psect); - } - break; - - case TIR_S_C_STA_PL: - case TIR_S_C_STA_WPL: - /* - * stack psect base plus long offset (word index) - * arg: by section index - * (sh section index) - * lw signed longword offset - * - */ - { - unsigned long dummy; - unsigned int psect; - - if (cmd == TIR_S_C_STA_PL) - psect = *ptr++; - else - { - psect = bfd_getl16(ptr); - ptr += 2; - } + case TIR_S_C_STA_PB: + case TIR_S_C_STA_WPB: + /* stack psect base plus byte offset (word index) + arg: by section index + (sh section index) + by signed byte offset. */ + { + unsigned long dummy; + unsigned int psect; - if (psect >= PRIV(section_count)) - { - alloc_section (abfd, psect); - } + if (cmd == TIR_S_C_STA_PB) + psect = *ptr++; + else + { + psect = bfd_getl16 (ptr); + ptr += 2; + } - dummy = bfd_getl32 (ptr); ptr += 4; - dummy += (PRIV(sections)[psect])->vma; - _bfd_vms_push (abfd, dummy, psect); - } - break; - - case TIR_S_C_STA_UB: - /* - * stack unsigned byte - * arg: by value - * - * stack byte value - */ - _bfd_vms_push (abfd, (unsigned long)*ptr++, -1); - break; - - case TIR_S_C_STA_UW: - /* - * stack unsigned short word - * arg: sh value - * - * stack 16 bit value - */ - _bfd_vms_push (abfd, (unsigned long)bfd_getl16(ptr), -1); - ptr += 2; + if (psect >= PRIV (section_count)) + alloc_section (abfd, psect); + + dummy = (long) *ptr++; + dummy += (PRIV (sections)[psect])->vma; + _bfd_vms_push (abfd, (uquad) dummy, (int) psect); + } break; - case TIR_S_C_STA_BFI: - /* - * stack byte from image - * arg: - - * - */ - /*FALLTHRU*/ - case TIR_S_C_STA_WFI: - /* - * stack byte from image - * arg: - - * - */ - /*FALLTHRU*/ - case TIR_S_C_STA_LFI: - /* - * stack byte from image - * arg: - - * - */ - (*_bfd_error_handler) (_("Stack-from-image not implemented")); - return NULL; - - case TIR_S_C_STA_EPM: - /* - * stack entry point mask - * arg: cs symbol name - * - * stack (unsigned) entry point mask of symbol - * err if symbol is no entry point - */ - { - char *name; - vms_symbol_entry *entry; + case TIR_S_C_STA_PW: + case TIR_S_C_STA_WPW: + /* stack psect base plus word offset (word index) + arg: by section index + (sh section index) + sh signed short offset. */ + { + unsigned long dummy; + unsigned int psect; - name = _bfd_vms_save_counted_string (ptr); - entry = _bfd_vms_enter_symbol (abfd, name); - if (entry == (vms_symbol_entry *)NULL) - return 0; + if (cmd == TIR_S_C_STA_PW) + psect = *ptr++; + else + { + psect = bfd_getl16 (ptr); + ptr += 2; + } - (*_bfd_error_handler) (_("Stack-entry-mask not fully implemented")); - _bfd_vms_push (abfd, 0L, -1); - ptr += *ptr + 1; - } + if (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); + } break; - case TIR_S_C_STA_CKARG: - /* - * compare procedure argument - * arg: cs symbol name - * by argument index - * da argument descriptor - * - * compare argument descriptor with symbol argument (ARG$V_PASSMECH) - * and stack TRUE (args match) or FALSE (args dont match) value - */ - (*_bfd_error_handler) (_("PASSMECH not fully implemented")); - _bfd_vms_push (abfd, 1L, -1); - break; + case TIR_S_C_STA_PL: + case TIR_S_C_STA_WPL: + /* stack psect base plus long offset (word index) + arg: by section index + (sh section index) + lw signed longword offset. */ + { + unsigned long dummy; + unsigned int psect; - case TIR_S_C_STA_LSY: - /* - * stack local symbol value - * arg: sh environment index - * cs symbol name - */ - { - int envidx; - char *name; - vms_symbol_entry *entry; - - envidx = bfd_getl16(ptr); ptr += 2; - name = _bfd_vms_save_counted_string (ptr); - entry = _bfd_vms_enter_symbol (abfd, name); - if (entry == (vms_symbol_entry *)NULL) - return 0; - (*_bfd_error_handler) (_("Stack-local-symbol not fully implemented")); - _bfd_vms_push (abfd, 0L, -1); - ptr += *ptr + 1; - } + if (cmd == TIR_S_C_STA_PL) + psect = *ptr++; + else + { + psect = bfd_getl16 (ptr); + ptr += 2; + } + + if (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); + } break; - case TIR_S_C_STA_LIT: - /* - * stack literal - * arg: by literal index - * - * stack literal - */ - ptr++; - _bfd_vms_push (abfd, 0L, -1); - (*_bfd_error_handler) (_("Stack-literal not fully implemented")); - break; + case TIR_S_C_STA_UB: + /* stack unsigned byte + arg: by value - case TIR_S_C_STA_LEPM: - /* - * stack local symbol entry point mask - * arg: sh environment index - * cs symbol name - * - * stack (unsigned) entry point mask of symbol - * err if symbol is no entry point - */ - { - int envidx; - char *name; - vms_symbol_entry *entry; - - envidx = bfd_getl16(ptr); ptr += 2; - name = _bfd_vms_save_counted_string (ptr); - entry = _bfd_vms_enter_symbol (abfd, name); - if (entry == (vms_symbol_entry *)NULL) - return 0; - (*_bfd_error_handler) (_("Stack-local-symbol-entry-point-mask not fully implemented")); - _bfd_vms_push (abfd, 0L, -1); - ptr += *ptr + 1; - } + stack byte value. */ + _bfd_vms_push (abfd, (uquad) *ptr++, -1); break; - default: - (*_bfd_error_handler) (_("Reserved STA cmd %d"), ptr[-1]); - return NULL; + case TIR_S_C_STA_UW: + /* stack unsigned short word + arg: sh value + + stack 16 bit value. */ + _bfd_vms_push (abfd, (uquad) bfd_getl16 (ptr), -1); + ptr += 2; break; - } + + case TIR_S_C_STA_BFI: + /* stack byte from image + arg: none. */ + /* FALLTHRU */ + case TIR_S_C_STA_WFI: + /* stack byte from image + arg: none. */ + /* FALLTHRU */ + case TIR_S_C_STA_LFI: + /* stack byte from image + arg: none. */ + (*_bfd_error_handler) (_("stack-from-image not implemented")); + return NULL; + + case TIR_S_C_STA_EPM: + /* stack entry point mask + arg: cs symbol name + + stack (unsigned) entry point mask of symbol + err if symbol is no entry point. */ + { + char *name; + vms_symbol_entry *entry; + + name = _bfd_vms_save_counted_string (ptr); + entry = _bfd_vms_enter_symbol (abfd, name); + if (entry == NULL) + return NULL; + + (*_bfd_error_handler) (_("stack-entry-mask not fully implemented")); + _bfd_vms_push (abfd, (uquad) 0, -1); + ptr += *ptr + 1; + } + break; + + case TIR_S_C_STA_CKARG: + /* compare procedure argument + arg: cs symbol name + by argument index + da argument descriptor + + compare argument descriptor with symbol argument (ARG$V_PASSMECH) + and stack TRUE (args match) or FALSE (args dont match) value. */ + (*_bfd_error_handler) (_("PASSMECH not fully implemented")); + _bfd_vms_push (abfd, (uquad) 1, -1); + break; + + case TIR_S_C_STA_LSY: + /* stack local symbol value + arg: sh environment index + cs symbol name. */ + { + int envidx; + char *name; + vms_symbol_entry *entry; + + envidx = bfd_getl16 (ptr); + ptr += 2; + name = _bfd_vms_save_counted_string (ptr); + entry = _bfd_vms_enter_symbol (abfd, name); + if (entry == NULL) + return NULL; + (*_bfd_error_handler) (_("stack-local-symbol not fully implemented")); + _bfd_vms_push (abfd, (uquad) 0, -1); + ptr += *ptr + 1; + } + break; + + case TIR_S_C_STA_LIT: + /* stack literal + arg: by literal index + + stack literal. */ + ptr++; + _bfd_vms_push (abfd, (uquad) 0, -1); + (*_bfd_error_handler) (_("stack-literal not fully implemented")); + break; + + case TIR_S_C_STA_LEPM: + /* stack local symbol entry point mask + arg: sh environment index + cs symbol name + + stack (unsigned) entry point mask of symbol + err if symbol is no entry point. */ + { + int envidx; + char *name; + vms_symbol_entry *entry; + + envidx = bfd_getl16 (ptr); + ptr += 2; + name = _bfd_vms_save_counted_string (ptr); + entry = _bfd_vms_enter_symbol (abfd, name); + if (entry == NULL) + return NULL; + (*_bfd_error_handler) (_("stack-local-symbol-entry-point-mask not fully implemented")); + _bfd_vms_push (abfd, (uquad) 0, -1); + ptr += *ptr + 1; + } + break; + + default: + (*_bfd_error_handler) (_("reserved STA cmd %d"), ptr[-1]); + return NULL; + break; + } return ptr; } +static const char * +tir_cmd_name (int cmd) +{ + switch (cmd) + { + case TIR_S_C_STO_RSB: return "TIR_S_C_STO_RSB"; + case TIR_S_C_STO_RSW: return "TIR_S_C_STO_RSW"; + case TIR_S_C_STO_RL: return "TIR_S_C_STO_RL"; + case TIR_S_C_STO_VPS: return "TIR_S_C_STO_VPS"; + case TIR_S_C_STO_USB: return "TIR_S_C_STO_USB"; + case TIR_S_C_STO_USW: return "TIR_S_C_STO_USW"; + case TIR_S_C_STO_RUB: return "TIR_S_C_STO_RUB"; + case TIR_S_C_STO_RUW: return "TIR_S_C_STO_RUW"; + case TIR_S_C_STO_PIRR: return "TIR_S_C_STO_PIRR"; + case TIR_S_C_OPR_INSV: return "TIR_S_C_OPR_INSV"; + case TIR_S_C_OPR_DFLIT: return "TIR_S_C_OPR_DFLIT"; + case TIR_S_C_OPR_REDEF: return "TIR_S_C_OPR_REDEF"; + case TIR_S_C_OPR_ROT: return "TIR_S_C_OPR_ROT"; + case TIR_S_C_OPR_USH: return "TIR_S_C_OPR_USH"; + case TIR_S_C_OPR_ASH: return "TIR_S_C_OPR_ASH"; + case TIR_S_C_CTL_DFLOC: return "TIR_S_C_CTL_DFLOC"; + case TIR_S_C_CTL_STLOC: return "TIR_S_C_CTL_STLOC"; + case TIR_S_C_CTL_STKDL: return "TIR_S_C_CTL_STKDL"; + + default: + /* These strings have not been added yet. */ + abort (); + } +} + +/* tir_sto -/* - * tir_sto - * - * vax store commands - * - * handle sto_xxx commands in tir section - * ptr points to data area in record - * - * see table 7-4 of the VAX/VMS linker manual - */ + vax store commands + + handle sto_xxx commands in tir section + ptr points to data area in record + + See table 7-4 of the VAX/VMS linker manual. */ static unsigned char * -tir_sto (bfd *abfd, unsigned char *ptr) +tir_sto (bfd * abfd, unsigned char *ptr) { unsigned long dummy; int size; @@ -1317,165 +1175,143 @@ tir_sto (bfd *abfd, unsigned char *ptr) switch (*ptr++) { - case TIR_S_C_STO_SB: - /* - * store signed byte: pop stack, write byte - * arg: - - */ - dummy = _bfd_vms_pop (abfd, &psect); - image_write_b (abfd, dummy & 0xff); /* FIXME: check top bits */ - break; - - case TIR_S_C_STO_SW: - /* - * store signed word: pop stack, write word - * arg: - - */ - dummy = _bfd_vms_pop (abfd, &psect); - image_write_w (abfd, dummy & 0xffff); /* FIXME: check top bits */ - break; - - case TIR_S_C_STO_LW: - /* - * store longword: pop stack, write longword - * arg: - - */ - dummy = _bfd_vms_pop (abfd, &psect); - image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */ - break; - - case TIR_S_C_STO_BD: - /* - * store byte displaced: pop stack, sub lc+1, write byte - * arg: - - */ - dummy = _bfd_vms_pop (abfd, &psect); - dummy -= ((PRIV(sections)[psect])->vma + 1); - image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */ - break; - - case TIR_S_C_STO_WD: - /* - * store word displaced: pop stack, sub lc+2, write word - * arg: - - */ - dummy = _bfd_vms_pop (abfd, &psect); - dummy -= ((PRIV(sections)[psect])->vma + 2); - image_write_w (abfd, dummy & 0xffff);/* FIXME: check top bits */ - break; - case TIR_S_C_STO_LD: - /* - * store long displaced: pop stack, sub lc+4, write long - * arg: - - */ - dummy = _bfd_vms_pop (abfd, &psect); - dummy -= ((PRIV(sections)[psect])->vma + 4); - image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */ - break; - case TIR_S_C_STO_LI: - /* - * store short literal: pop stack, write byte - * arg: - - */ - dummy = _bfd_vms_pop (abfd, &psect); - image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */ - break; - case TIR_S_C_STO_PIDR: - /* - * store position independent data reference: pop stack, write longword - * arg: - - * FIXME: incomplete ! - */ - dummy = _bfd_vms_pop (abfd, &psect); - image_write_l (abfd, dummy & 0xffffffff); - break; - case TIR_S_C_STO_PICR: - /* - * store position independent code reference: pop stack, write longword - * arg: - - * FIXME: incomplete ! - */ - dummy = _bfd_vms_pop (abfd, &psect); - image_write_b (abfd, 0x9f); - image_write_l (abfd, dummy & 0xffffffff); - break; - case TIR_S_C_STO_RIVB: - /* - * store repeated immediate variable bytes - * 1-byte count n field followed by n bytes of data - * pop stack, write n bytes times - */ - size = *ptr++; - dummy = (unsigned long)_bfd_vms_pop (abfd, NULL); - while (dummy-- > 0L) - image_dump (abfd, ptr, size, 0); - ptr += size; - break; - case TIR_S_C_STO_B: - /* - * store byte from top longword - */ - dummy = (unsigned long)_bfd_vms_pop (abfd, NULL); + case TIR_S_C_STO_SB: + /* Store signed byte: pop stack, write byte + arg: none. */ + dummy = _bfd_vms_pop (abfd, &psect); + image_write_b (abfd, dummy & 0xff); /* FIXME: check top bits */ + break; + + case TIR_S_C_STO_SW: + /* Store signed word: pop stack, write word + arg: none. */ + dummy = _bfd_vms_pop (abfd, &psect); + image_write_w (abfd, dummy & 0xffff); /* FIXME: check top bits */ + break; + + case TIR_S_C_STO_LW: + /* Store longword: pop stack, write longword + arg: none. */ + dummy = _bfd_vms_pop (abfd, &psect); + image_write_l (abfd, dummy & 0xffffffff); /* FIXME: check top bits */ + break; + + case TIR_S_C_STO_BD: + /* Store byte displaced: pop stack, sub lc+1, write byte + arg: none. */ + dummy = _bfd_vms_pop (abfd, &psect); + dummy -= ((PRIV (sections)[psect])->vma + 1); + image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */ + break; + + case TIR_S_C_STO_WD: + /* Store word displaced: pop stack, sub lc+2, write word + arg: none. */ + dummy = _bfd_vms_pop (abfd, &psect); + dummy -= ((PRIV (sections)[psect])->vma + 2); + image_write_w (abfd, dummy & 0xffff);/* FIXME: check top bits */ + break; + + case TIR_S_C_STO_LD: + /* Store long displaced: pop stack, sub lc+4, write long + arg: none. */ + dummy = _bfd_vms_pop (abfd, &psect); + dummy -= ((PRIV (sections)[psect])->vma + 4); + image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */ + break; + + case TIR_S_C_STO_LI: + /* Store short literal: pop stack, write byte + arg: none. */ + dummy = _bfd_vms_pop (abfd, &psect); + image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */ + break; + + case TIR_S_C_STO_PIDR: + /* Store position independent data reference: pop stack, write longword + arg: none. + FIXME: incomplete ! */ + dummy = _bfd_vms_pop (abfd, &psect); + image_write_l (abfd, dummy & 0xffffffff); + break; + + case TIR_S_C_STO_PICR: + /* Store position independent code reference: pop stack, write longword + arg: none. + FIXME: incomplete ! */ + dummy = _bfd_vms_pop (abfd, &psect); + image_write_b (abfd, 0x9f); + image_write_l (abfd, dummy & 0xffffffff); + break; + + case TIR_S_C_STO_RIVB: + /* Store repeated immediate variable bytes + 1-byte count n field followed by n bytes of data + pop stack, write n bytes times. */ + size = *ptr++; + dummy = (unsigned long) _bfd_vms_pop (abfd, NULL); + while (dummy-- > 0L) + image_dump (abfd, ptr, size, 0); + ptr += size; + break; + + case TIR_S_C_STO_B: + /* Store byte from top longword. */ + dummy = (unsigned long) _bfd_vms_pop (abfd, NULL); + image_write_b (abfd, dummy & 0xff); + break; + + case TIR_S_C_STO_W: + /* Store word from top longword. */ + dummy = (unsigned long) _bfd_vms_pop (abfd, NULL); + image_write_w (abfd, dummy & 0xffff); + break; + + case TIR_S_C_STO_RB: + /* Store repeated byte from top longword. */ + size = (unsigned long) _bfd_vms_pop (abfd, NULL); + dummy = (unsigned long) _bfd_vms_pop (abfd, NULL); + while (size-- > 0) image_write_b (abfd, dummy & 0xff); - break; - case TIR_S_C_STO_W: - /* - * store word from top longword - */ - dummy = (unsigned long)_bfd_vms_pop (abfd, NULL); + break; + + case TIR_S_C_STO_RW: + /* Store repeated word from top longword. */ + size = (unsigned long) _bfd_vms_pop (abfd, NULL); + dummy = (unsigned long) _bfd_vms_pop (abfd, NULL); + while (size-- > 0) image_write_w (abfd, dummy & 0xffff); - break; - case TIR_S_C_STO_RB: - /* - * store repeated byte from top longword - */ - size = (unsigned long)_bfd_vms_pop (abfd, NULL); - dummy = (unsigned long)_bfd_vms_pop (abfd, NULL); - while (size-- > 0) - image_write_b (abfd, dummy & 0xff); - break; - case TIR_S_C_STO_RW: - /* - * store repeated word from top longword - */ - size = (unsigned long)_bfd_vms_pop (abfd, NULL); - dummy = (unsigned long)_bfd_vms_pop (abfd, NULL); - while (size-- > 0) - image_write_w (abfd, dummy & 0xffff); - break; + break; - case TIR_S_C_STO_RSB: - case TIR_S_C_STO_RSW: - case TIR_S_C_STO_RL: - case TIR_S_C_STO_VPS: - case TIR_S_C_STO_USB: - case TIR_S_C_STO_USW: - case TIR_S_C_STO_RUB: - case TIR_S_C_STO_RUW: - case TIR_S_C_STO_PIRR: - (*_bfd_error_handler) (_("Unimplemented STO cmd %d"), ptr[-1]); + case TIR_S_C_STO_RSB: + case TIR_S_C_STO_RSW: + case TIR_S_C_STO_RL: + case TIR_S_C_STO_VPS: + case TIR_S_C_STO_USB: + case TIR_S_C_STO_USW: + case TIR_S_C_STO_RUB: + case TIR_S_C_STO_RUW: + case TIR_S_C_STO_PIRR: + (*_bfd_error_handler) (_("%s: not implemented"), tir_cmd_name (ptr[-1])); break; - default: - (*_bfd_error_handler) (_("Reserved STO cmd %d"), ptr[-1]); + default: + (*_bfd_error_handler) (_("reserved STO cmd %d"), ptr[-1]); break; - } + } return ptr; } +/* Stack operator commands + All 32 bit signed arithmetic + All word just like a stack calculator + Arguments are popped from stack, results are pushed on stack -/* - * stack operator commands - * all 32 bit signed arithmetic - * all word just like a stack calculator - * arguments are popped from stack, results are pushed on stack - * - * see table 7-5 of the VAX/VMS linker manual - */ + See table 7-5 of the VAX/VMS linker manual. */ static unsigned char * -tir_opr (bfd *abfd, unsigned char *ptr) +tir_opr (bfd * abfd, unsigned char *ptr) { long op1, op2; @@ -1483,191 +1319,140 @@ tir_opr (bfd *abfd, unsigned char *ptr) _bfd_vms_debug (5, "tir_opr %d\n", *ptr); #endif + /* Operation. */ switch (*ptr++) { - /* operation */ - case TIR_S_C_OPR_NOP: - /* - * no-op - */ - break; - - case TIR_S_C_OPR_ADD: - /* - * add - */ - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (unsigned long)(op1 + op2), -1); - break; - - case TIR_S_C_OPR_SUB: - /* - * subtract - */ - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (unsigned long)(op2 - op1), -1); - break; - - case TIR_S_C_OPR_MUL: - /* - * multiply - */ - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (unsigned long)(op1 * op2), -1); - break; - - case TIR_S_C_OPR_DIV: - /* - * divide - */ - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - if (op2 == 0) - _bfd_vms_push (abfd, (unsigned long)0L, -1); - else - _bfd_vms_push (abfd, (unsigned long)(op2 / op1), -1); - break; - - case TIR_S_C_OPR_AND: - /* - * logical and - */ - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (unsigned long)(op1 & op2), -1); - break; - - case TIR_S_C_OPR_IOR: - op1 = (long)_bfd_vms_pop (abfd, NULL); - /* - * logical inclusive or - */ - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (unsigned long)(op1 | op2), -1); - break; - - case TIR_S_C_OPR_EOR: - /* - * logical exclusive or - */ - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (unsigned long)(op1 ^ op2), -1); - break; - - case TIR_S_C_OPR_NEG: - /* - * negate - */ - op1 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (unsigned long)(-op1), -1); - break; - - case TIR_S_C_OPR_COM: - /* - * complement - */ - op1 = (long)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (unsigned long)(op1 ^ -1L), -1); - break; - - case TIR_S_C_OPR_INSV: - /* - * insert field - */ - (void)_bfd_vms_pop (abfd, NULL); - (*_bfd_error_handler) ("TIR_S_C_OPR_INSV incomplete"); - break; - - case TIR_S_C_OPR_ASH: - /* - * arithmetic shift - */ - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - if (HIGHBIT(op1)) /* shift right */ - op2 >>= op1; - else /* shift left */ - op2 <<= op1; - _bfd_vms_push (abfd, (unsigned long)op2, -1); - (*_bfd_error_handler) (_("TIR_S_C_OPR_ASH incomplete")); - break; - - case TIR_S_C_OPR_USH: - /* - * unsigned shift - */ - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - if (HIGHBIT(op1)) /* shift right */ - op2 >>= op1; - else /* shift left */ - op2 <<= op1; - _bfd_vms_push (abfd, (unsigned long)op2, -1); - (*_bfd_error_handler) (_("TIR_S_C_OPR_USH incomplete")); - break; - - case TIR_S_C_OPR_ROT: - /* - * rotate - */ - op1 = (long)_bfd_vms_pop (abfd, NULL); - op2 = (long)_bfd_vms_pop (abfd, NULL); - if (HIGHBIT(0)) /* shift right */ - op2 >>= op1; - else /* shift left */ - op2 <<= op1; - _bfd_vms_push (abfd, (unsigned long)op2, -1); - (*_bfd_error_handler) (_("TIR_S_C_OPR_ROT incomplete")); - break; - - case TIR_S_C_OPR_SEL: - /* - * select - */ - if ((long)_bfd_vms_pop (abfd, NULL) & 0x01L) - (void)_bfd_vms_pop (abfd, NULL); - else - { - op1 = (long)_bfd_vms_pop (abfd, NULL); - (void)_bfd_vms_pop (abfd, NULL); - _bfd_vms_push (abfd, (unsigned long)op1, -1); - } + case TIR_S_C_OPR_NOP: /* No-op. */ break; - case TIR_S_C_OPR_REDEF: - /* - * redefine symbol to current location - */ - (*_bfd_error_handler) (_("TIR_S_C_OPR_REDEF not supported")); + case TIR_S_C_OPR_ADD: /* Add. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 + op2), -1); break; - case TIR_S_C_OPR_DFLIT: - /* - * define a literal - */ - (*_bfd_error_handler) (_("TIR_S_C_OPR_DFLIT not supported")); + case TIR_S_C_OPR_SUB: /* Subtract. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op2 - op1), -1); break; - default: - (*_bfd_error_handler) (_("Reserved OPR cmd %d"), ptr[-1]); + case TIR_S_C_OPR_MUL: /* Multiply. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 * op2), -1); + break; + + case TIR_S_C_OPR_DIV: /* Divide. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + if (op2 == 0) + _bfd_vms_push (abfd, (uquad) 0, -1); + else + _bfd_vms_push (abfd, (uquad) (op2 / op1), -1); + break; + + case TIR_S_C_OPR_AND: /* Logical AND. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 & op2), -1); + break; + + case TIR_S_C_OPR_IOR: /* Logical inclusive OR. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 | op2), -1); + break; + + case TIR_S_C_OPR_EOR: /* Logical exclusive OR. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 ^ op2), -1); + break; + + case TIR_S_C_OPR_NEG: /* Negate. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (-op1), -1); + break; + + case TIR_S_C_OPR_COM: /* Complement. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) (op1 ^ -1L), -1); + break; + + case TIR_S_C_OPR_INSV: /* Insert field. */ + (void) _bfd_vms_pop (abfd, NULL); + (*_bfd_error_handler) (_("%s: not fully implemented"), + tir_cmd_name (ptr[-1])); + break; + + case TIR_S_C_OPR_ASH: /* Arithmetic shift. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + if (HIGHBIT (op1)) /* Shift right. */ + op2 >>= op1; + else /* Shift left. */ + op2 <<= op1; + _bfd_vms_push (abfd, (uquad) op2, -1); + (*_bfd_error_handler) (_("%s: not fully implemented"), + tir_cmd_name (ptr[-1])); + break; + + case TIR_S_C_OPR_USH: /* Unsigned shift. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + if (HIGHBIT (op1)) /* Shift right. */ + op2 >>= op1; + else /* Shift left. */ + op2 <<= op1; + _bfd_vms_push (abfd, (uquad) op2, -1); + (*_bfd_error_handler) (_("%s: not fully implemented"), + tir_cmd_name (ptr[-1])); + break; + + case TIR_S_C_OPR_ROT: /* Rotate. */ + op1 = (long) _bfd_vms_pop (abfd, NULL); + op2 = (long) _bfd_vms_pop (abfd, NULL); + if (HIGHBIT (0)) /* Shift right. */ + op2 >>= op1; + else /* Shift left. */ + op2 <<= op1; + _bfd_vms_push (abfd, (uquad) op2, -1); + (*_bfd_error_handler) (_("%s: not fully implemented"), + tir_cmd_name (ptr[-1])); + break; + + case TIR_S_C_OPR_SEL: /* Select. */ + if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L) + (void) _bfd_vms_pop (abfd, NULL); + else + { + op1 = (long) _bfd_vms_pop (abfd, NULL); + (void) _bfd_vms_pop (abfd, NULL); + _bfd_vms_push (abfd, (uquad) op1, -1); + } + break; + + case TIR_S_C_OPR_REDEF: /* Redefine symbol to current location. */ + case TIR_S_C_OPR_DFLIT: /* Define a literal. */ + (*_bfd_error_handler) (_("%s: not supported"), + tir_cmd_name (ptr[-1])); + break; + + default: + (*_bfd_error_handler) (_("reserved OPR cmd %d"), ptr[-1]); break; } return ptr; } +/* Control commands + + See table 7-6 of the VAX/VMS linker manual. */ static unsigned char * -tir_ctl (bfd *abfd, unsigned char *ptr) -/* - * control commands - * - * see table 7-6 of the VAX/VMS linker manual - */ +tir_ctl (bfd * abfd, unsigned char *ptr) { unsigned long dummy; unsigned int psect; @@ -1678,85 +1463,82 @@ tir_ctl (bfd *abfd, unsigned char *ptr) switch (*ptr++) { - case TIR_S_C_CTL_SETRB: - /* - * set relocation base: pop stack, set image location counter - * arg: - - */ - dummy = _bfd_vms_pop (abfd, &psect); - if (psect >= PRIV(section_count)) - { - alloc_section (abfd, psect); - } - image_set_ptr (abfd, psect, dummy); - break; - case TIR_S_C_CTL_AUGRB: - /* - * augment relocation base: increment image location counter by offset - * arg: lw offset value - */ - dummy = bfd_getl32 (ptr); - image_inc_ptr (abfd, dummy); - break; - case TIR_S_C_CTL_DFLOC: - /* - * define location: pop index, save location counter under index - * arg: - - */ - dummy = _bfd_vms_pop (abfd, NULL); - (*_bfd_error_handler) (_("TIR_S_C_CTL_DFLOC not fully implemented")); - break; - case TIR_S_C_CTL_STLOC: - /* - * set location: pop index, restore location counter from index - * arg: - - */ - dummy = _bfd_vms_pop (abfd, &psect); - (*_bfd_error_handler) (_("TIR_S_C_CTL_STLOC not fully implemented")); + 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)) + alloc_section (abfd, psect); + image_set_ptr (abfd, (int) psect, (uquad) dummy); + break; + + case TIR_S_C_CTL_AUGRB: + /* Augment relocation base: increment image location counter by offset + arg: lw offset value. */ + dummy = bfd_getl32 (ptr); + image_inc_ptr (abfd, (uquad) dummy); break; + + case TIR_S_C_CTL_DFLOC: + /* Define location: pop index, save location counter under index + arg: none. */ + dummy = _bfd_vms_pop (abfd, NULL); + (*_bfd_error_handler) (_("%s: not fully implemented"), + tir_cmd_name (ptr[-1])); + break; + + case TIR_S_C_CTL_STLOC: + /* Set location: pop index, restore location counter from index + arg: none. */ + dummy = _bfd_vms_pop (abfd, (int *) &psect); + (*_bfd_error_handler) (_("%s: not fully implemented"), + tir_cmd_name (ptr[-1])); + break; + case TIR_S_C_CTL_STKDL: - /* - * stack defined location: pop index, push location counter from index - * arg: - - */ - dummy = _bfd_vms_pop (abfd, &psect); - (*_bfd_error_handler) (_("TIR_S_C_CTL_STKDL not fully implemented")); + /* Stack defined location: pop index, push location counter from index + arg: none. */ + dummy = _bfd_vms_pop (abfd, (int *) &psect); + (*_bfd_error_handler) (_("%s: not fully implemented"), + tir_cmd_name (ptr[-1])); break; + default: - (*_bfd_error_handler) (_("Reserved CTL cmd %d"), ptr[-1]); - break; - } + (*_bfd_error_handler) (_("reserved CTL cmd %d"), ptr[-1]); + break; + } return ptr; } - -/* - * handle command from TIR section - */ +/* Handle command from TIR section. */ static unsigned char * -tir_cmd (bfd *abfd, unsigned char *ptr) +tir_cmd (bfd * abfd, unsigned char *ptr) { - struct { + struct + { int mincod; int maxcod; - unsigned char * (*explain)(bfd *, unsigned char *); - } tir_table[] = { - { 0, TIR_S_C_MAXSTACOD, tir_sta } - ,{ TIR_S_C_MINSTOCOD, TIR_S_C_MAXSTOCOD, tir_sto } - ,{ TIR_S_C_MINOPRCOD, TIR_S_C_MAXOPRCOD, tir_opr } - ,{ TIR_S_C_MINCTLCOD, TIR_S_C_MAXCTLCOD, tir_ctl } - ,{ -1, -1, NULL } + unsigned char * (*explain) (bfd *, unsigned char *); + } + tir_table[] = + { + { 0, TIR_S_C_MAXSTACOD, tir_sta }, + { TIR_S_C_MINSTOCOD, TIR_S_C_MAXSTOCOD, tir_sto }, + { TIR_S_C_MINOPRCOD, TIR_S_C_MAXOPRCOD, tir_opr }, + { TIR_S_C_MINCTLCOD, TIR_S_C_MAXCTLCOD, tir_ctl }, + { -1, -1, NULL } }; int i = 0; #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, (int) ptr); #endif - if (*ptr & 0x80) /* store immediate */ + if (*ptr & 0x80) { + /* Store immediate. */ i = 128 - (*ptr++ & 0x7f); image_dump (abfd, ptr, i, 0); ptr += i; @@ -1765,8 +1547,8 @@ tir_cmd (bfd *abfd, unsigned char *ptr) { while (tir_table[i].mincod >= 0) { - if ( (tir_table[i].mincod <= *ptr) - && (*ptr <= tir_table[i].maxcod)) + if ( (tir_table[i].mincod <= *ptr) + && (*ptr <= tir_table[i].maxcod)) { ptr = tir_table[i].explain (abfd, ptr); break; @@ -1775,7 +1557,7 @@ tir_cmd (bfd *abfd, unsigned char *ptr) } if (tir_table[i].mincod < 0) { - (*_bfd_error_handler) (_("Obj code %d not found"), *ptr); + (*_bfd_error_handler) (_("obj code %d not found"), *ptr); ptr = 0; } } @@ -1783,20 +1565,19 @@ tir_cmd (bfd *abfd, unsigned char *ptr) return ptr; } - -/* handle command from ETIR section */ +/* Handle command from ETIR section. */ static int -etir_cmd (abfd, cmd, ptr) - bfd *abfd; - int cmd; - unsigned char *ptr; +etir_cmd (bfd * abfd, int cmd, unsigned char *ptr) { - static struct { + static struct + { int mincod; int maxcod; - boolean (*explain) PARAMS((bfd *, int, unsigned char *)); - } etir_table[] = { + bfd_boolean (*explain) (bfd *, int, unsigned char *); + } + etir_table[] = + { { ETIR_S_C_MINSTACOD, ETIR_S_C_MAXSTACOD, etir_sta }, { ETIR_S_C_MINSTOCOD, ETIR_S_C_MAXSTOCOD, etir_sto }, { ETIR_S_C_MINOPRCOD, ETIR_S_C_MAXOPRCOD, etir_opr }, @@ -1809,13 +1590,13 @@ etir_cmd (abfd, cmd, ptr) #if VMS_DEBUG _bfd_vms_debug (4, "etir_cmd %d/%x\n", cmd, cmd); - _bfd_hexdump (8, ptr, 16, (int)ptr); + _bfd_hexdump (8, ptr, 16, (int) ptr); #endif while (etir_table[i].mincod >= 0) { - if ( (etir_table[i].mincod <= cmd) - && (cmd <= etir_table[i].maxcod)) + if ( (etir_table[i].mincod <= cmd) + && (cmd <= etir_table[i].maxcod)) { if (!etir_table[i].explain (abfd, cmd, ptr)) return -1; @@ -1830,15 +1611,11 @@ etir_cmd (abfd, cmd, ptr) return 0; } - /* Text Information and Relocation Records (OBJ$C_TIR) - handle tir record */ + handle tir record. */ static int -analyze_tir (abfd, ptr, length) - bfd *abfd; - unsigned char *ptr; - unsigned int length; +analyze_tir (bfd * abfd, unsigned char *ptr, unsigned int length) { unsigned char *maxptr; @@ -1858,15 +1635,11 @@ analyze_tir (abfd, ptr, length) return 0; } - /* Text Information and Relocation Records (EOBJ$C_ETIR) - handle etir record */ + handle etir record. */ static int -analyze_etir (abfd, ptr, length) - bfd *abfd; - unsigned char *ptr; - unsigned int length; +analyze_etir (bfd * abfd, unsigned char *ptr, unsigned int length) { int cmd; unsigned char *maxptr; @@ -1895,15 +1668,11 @@ analyze_etir (abfd, ptr, length) return result; } - -/* process ETIR record - - return 0 on success, -1 on error */ +/* Process ETIR record + Return 0 on success, -1 on error. */ int -_bfd_vms_slurp_tir (abfd, objtype) - bfd *abfd; - int objtype; +_bfd_vms_slurp_tir (bfd * abfd, int objtype) { int result; @@ -1913,34 +1682,31 @@ _bfd_vms_slurp_tir (abfd, objtype) switch (objtype) { - case EOBJ_S_C_ETIR: - PRIV(vms_rec) += 4; /* skip type, size */ - PRIV(rec_size) -= 4; - result = analyze_etir (abfd, PRIV(vms_rec), PRIV(rec_size)); - break; - case OBJ_S_C_TIR: - PRIV(vms_rec) += 1; /* skip type */ - PRIV(rec_size) -= 1; - result = analyze_tir (abfd, PRIV(vms_rec), PRIV(rec_size)); - break; - default: - result = -1; - break; + case EOBJ_S_C_ETIR: + PRIV (vms_rec) += 4; /* Skip type, size. */ + PRIV (rec_size) -= 4; + result = analyze_etir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size)); + break; + case OBJ_S_C_TIR: + PRIV (vms_rec) += 1; /* Skip type. */ + PRIV (rec_size) -= 1; + result = analyze_tir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size)); + break; + default: + result = -1; + break; } return result; } +/* Process EDBG record + Return 0 on success, -1 on error -/* process EDBG record - return 0 on success, -1 on error - - not implemented yet */ + Not implemented yet. */ int -_bfd_vms_slurp_dbg (abfd, objtype) - bfd *abfd; - int objtype ATTRIBUTE_UNUSED; +_bfd_vms_slurp_dbg (bfd * abfd, int objtype ATTRIBUTE_UNUSED) { #if VMS_DEBUG _bfd_vms_debug (2, "DBG/EDBG\n"); @@ -1950,16 +1716,14 @@ _bfd_vms_slurp_dbg (abfd, objtype) return 0; } +/* Process ETBT record + Return 0 on success, -1 on error -/* process ETBT record - return 0 on success, -1 on error - - not implemented yet */ + Not implemented yet. */ int -_bfd_vms_slurp_tbt (abfd, objtype) - bfd *abfd ATTRIBUTE_UNUSED; - int objtype ATTRIBUTE_UNUSED; +_bfd_vms_slurp_tbt (bfd * abfd ATTRIBUTE_UNUSED, + int objtype ATTRIBUTE_UNUSED) { #if VMS_DEBUG _bfd_vms_debug (2, "TBT/ETBT\n"); @@ -1968,16 +1732,14 @@ _bfd_vms_slurp_tbt (abfd, objtype) return 0; } +/* Process LNK record + Return 0 on success, -1 on error -/* process LNK record - return 0 on success, -1 on error - - not implemented yet */ + Not implemented yet. */ int -_bfd_vms_slurp_lnk (abfd, objtype) - bfd *abfd ATTRIBUTE_UNUSED; - int objtype ATTRIBUTE_UNUSED; +_bfd_vms_slurp_lnk (bfd * abfd ATTRIBUTE_UNUSED, + int objtype ATTRIBUTE_UNUSED) { #if VMS_DEBUG _bfd_vms_debug (2, "LNK\n"); @@ -1986,24 +1748,42 @@ _bfd_vms_slurp_lnk (abfd, objtype) return 0; } -/*----------------------------------------------------------------------*/ -/* */ -/* WRITE ETIR SECTION */ -/* */ -/* this is still under construction and therefore not documented */ -/* */ -/*----------------------------------------------------------------------*/ - -static void start_etir_record PARAMS ((bfd *abfd, int index, uquad offset, boolean justoffset)); -static void sto_imm PARAMS ((bfd *abfd, vms_section *sptr, bfd_vma vaddr, int index)); -static void end_etir_record PARAMS ((bfd *abfd)); +/* Start ETIR record for section #index at virtual addr offset. */ + +static void +start_etir_record (bfd * abfd, int index, uquad offset, bfd_boolean justoffset) +{ + if (!justoffset) + { + /* One ETIR per section. */ + _bfd_vms_output_begin (abfd, EOBJ_S_C_ETIR, -1); + _bfd_vms_output_push (abfd); + } + + /* Push start offset. */ + _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1); + _bfd_vms_output_long (abfd, (unsigned long) index); + _bfd_vms_output_quad (abfd, (uquad) offset); + _bfd_vms_output_flush (abfd); + + /* Start = pop (). */ + _bfd_vms_output_begin (abfd, ETIR_S_C_CTL_SETRB, -1); + _bfd_vms_output_flush (abfd); +} + +static void +end_etir_record (bfd * abfd) +{ + _bfd_vms_output_pop (abfd); + _bfd_vms_output_end (abfd); +} + +/* WRITE ETIR SECTION + + This is still under construction and therefore not documented. */ static void -sto_imm (abfd, sptr, vaddr, index) - bfd *abfd; - vms_section *sptr; - bfd_vma vaddr; - int index; +sto_imm (bfd * abfd, vms_section *sptr, bfd_vma vaddr, int index) { int size; int ssize; @@ -2011,7 +1791,7 @@ sto_imm (abfd, sptr, vaddr, index) #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_hexdump (9, sptr->contents, (int) sptr->size, (int) vaddr); #endif ssize = sptr->size; @@ -2019,80 +1799,41 @@ sto_imm (abfd, sptr, vaddr, index) while (ssize > 0) { - - size = ssize; /* try all the rest */ + /* Try all the rest. */ + size = ssize; if (_bfd_vms_output_check (abfd, size) < 0) - { /* doesn't fit, split ! */ + { + /* Doesn't fit, split ! */ end_etir_record (abfd); - 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 ? */ + 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) size = ssize; } _bfd_vms_output_begin (abfd, ETIR_S_C_STO_IMM, -1); - _bfd_vms_output_long (abfd, (unsigned long)(size)); + _bfd_vms_output_long (abfd, (unsigned long) (size)); _bfd_vms_output_dump (abfd, cptr, size); _bfd_vms_output_flush (abfd); #if VMS_DEBUG _bfd_vms_debug (10, "dumped %d bytes\n", size); - _bfd_hexdump (10, cptr, (int)size, (int)vaddr); + _bfd_hexdump (10, cptr, (int) size, (int) vaddr); #endif vaddr += size; ssize -= size; cptr += size; } - - return; -} - -/*-------------------------------------------------------------------*/ - -/* start ETIR record for section #index at virtual addr offset. */ - -static void -start_etir_record (abfd, index, offset, justoffset) - bfd *abfd; - int index; - uquad offset; - boolean justoffset; -{ - if (!justoffset) - { - _bfd_vms_output_begin (abfd, EOBJ_S_C_ETIR, -1); /* one ETIR per section */ - _bfd_vms_output_push (abfd); - } - - _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1); /* push start offset */ - _bfd_vms_output_long (abfd, (unsigned long)index); - _bfd_vms_output_quad (abfd, (uquad)offset); - _bfd_vms_output_flush (abfd); - - _bfd_vms_output_begin (abfd, ETIR_S_C_CTL_SETRB, -1); /* start = pop () */ - _bfd_vms_output_flush (abfd); - - return; -} - - -/* end etir record */ -static void -end_etir_record (abfd) - bfd *abfd; -{ - _bfd_vms_output_pop (abfd); - _bfd_vms_output_end (abfd); } -/* write section contents for bfd abfd */ +/* Write section contents for bfd abfd. */ int -_bfd_vms_write_tir (abfd, objtype) - bfd *abfd; - int objtype ATTRIBUTE_UNUSED; +_bfd_vms_write_tir (bfd * abfd, int objtype ATTRIBUTE_UNUSED) { asection *section; vms_section *sptr; @@ -2105,17 +1846,18 @@ _bfd_vms_write_tir (abfd, objtype) _bfd_vms_output_alignment (abfd, 4); nextoffset = 0; - PRIV(vms_linkage_index) = 1; - - /* dump all other sections */ + PRIV (vms_linkage_index) = 1; + /* Dump all other sections. */ section = abfd->sections; while (section != NULL) { #if VMS_DEBUG - _bfd_vms_debug (4, "writing %d. section '%s' (%d bytes)\n", section->index, section->name, (int)(section->_raw_size)); + _bfd_vms_debug (4, "writing %d. section '%s' (%d bytes)\n", + section->index, section->name, + (int) (section->size)); #endif if (section->flags & SEC_RELOC) @@ -2123,10 +1865,8 @@ _bfd_vms_write_tir (abfd, objtype) int i; if ((i = section->reloc_count) <= 0) - { - (*_bfd_error_handler) (_("SEC_RELOC with no relocs in section %s"), - section->name); - } + (*_bfd_error_handler) (_("SEC_RELOC with no relocs in section %s"), + section->name); #if VMS_DEBUG else { @@ -2136,12 +1876,12 @@ _bfd_vms_write_tir (abfd, objtype) while (i-- > 0) { _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)->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++; } } @@ -2149,9 +1889,10 @@ _bfd_vms_write_tir (abfd, objtype) } if ((section->flags & SEC_HAS_CONTENTS) - && (! bfd_is_com_section (section))) + && (! bfd_is_com_section (section))) { - bfd_vma vaddr; /* virtual addr in section */ + /* Virtual addr in section. */ + bfd_vma vaddr; sptr = _bfd_get_vms_section (abfd, section->index); if (sptr == NULL) @@ -2160,34 +1901,40 @@ _bfd_vms_write_tir (abfd, objtype) return -1; } - vaddr = (bfd_vma)(sptr->offset); + vaddr = (bfd_vma) (sptr->offset); start_etir_record (abfd, section->index, (uquad) sptr->offset, - false); + FALSE); - while (sptr != NULL) /* one STA_PQ, CTL_SETRB per vms_section */ + while (sptr != NULL) { - - if (section->flags & SEC_RELOC) /* check for relocs */ + /* 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; + for (;;) { bfd_size_type addr = (*rptr)->address; bfd_size_type len = bfd_get_reloc_size ((*rptr)->howto); - if (sptr->offset < addr) /* sptr starts before reloc */ + if (sptr->offset < addr) { + /* Sptr starts before reloc. */ bfd_size_type before = addr - sptr->offset; - if (sptr->size <= before) /* complete before */ + if (sptr->size <= before) { + /* Complete before. */ sto_imm (abfd, sptr, vaddr, section->index); vaddr += sptr->size; break; } - else /* partly before */ + else { + /* Partly before. */ int after = sptr->size - before; + sptr->size = before; sto_imm (abfd, sptr, vaddr, section->index); vaddr += sptr->size; @@ -2196,8 +1943,9 @@ _bfd_vms_write_tir (abfd, objtype) sptr->size = after; } } - else if (sptr->offset == addr) /* sptr starts at reloc */ + else if (sptr->offset == addr) { + /* Sptr starts at reloc. */ asymbol *sym = *(*rptr)->sym_ptr_ptr; asection *sec = sym->section; @@ -2210,20 +1958,22 @@ _bfd_vms_write_tir (abfd, objtype) { if (bfd_is_und_section (sym->section)) { - if (_bfd_vms_output_check (abfd, - strlen((char *)sym->name)) - < 0) + 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); + vaddr, FALSE); } _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_GBL_LW, - -1); - _bfd_vms_output_counted (abfd, - _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ_S_C_SYMSIZ)); + 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)) @@ -2233,17 +1983,17 @@ _bfd_vms_write_tir (abfd, objtype) end_etir_record (abfd); start_etir_record (abfd, section->index, - vaddr, false); + vaddr, FALSE); } _bfd_vms_output_begin (abfd, - ETIR_S_C_STA_LW, - -1); + ETIR_S_C_STA_LW, + -1); _bfd_vms_output_quad (abfd, - (uquad)sym->value); + (uquad) sym->value); _bfd_vms_output_flush (abfd); _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_LW, - -1); + ETIR_S_C_STO_LW, + -1); _bfd_vms_output_flush (abfd); } else @@ -2253,20 +2003,20 @@ _bfd_vms_write_tir (abfd, objtype) end_etir_record (abfd); start_etir_record (abfd, section->index, - vaddr, false); + vaddr, FALSE); } _bfd_vms_output_begin (abfd, - ETIR_S_C_STA_PQ, - -1); + ETIR_S_C_STA_PQ, + -1); _bfd_vms_output_long (abfd, - (unsigned long)(sec->index)); + (unsigned long) (sec->index)); _bfd_vms_output_quad (abfd, - ((uquad)(*rptr)->addend - + (uquad)sym->value)); + ((uquad) (*rptr)->addend + + (uquad) sym->value)); _bfd_vms_output_flush (abfd); _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_LW, - -1); + ETIR_S_C_STO_LW, + -1); _bfd_vms_output_flush (abfd); } } @@ -2276,20 +2026,22 @@ _bfd_vms_write_tir (abfd, objtype) { if (bfd_is_und_section (sym->section)) { - if (_bfd_vms_output_check (abfd, - strlen((char *)sym->name)) - < 0) + 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); + vaddr, FALSE); } _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_GBL, - -1); - _bfd_vms_output_counted (abfd, - _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ_S_C_SYMSIZ)); + 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)) @@ -2299,17 +2051,17 @@ _bfd_vms_write_tir (abfd, objtype) end_etir_record (abfd); start_etir_record (abfd, section->index, - vaddr, false); + vaddr, FALSE); } _bfd_vms_output_begin (abfd, - ETIR_S_C_STA_QW, - -1); + ETIR_S_C_STA_QW, + -1); _bfd_vms_output_quad (abfd, - (uquad)sym->value); + (uquad) sym->value); _bfd_vms_output_flush (abfd); _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_QW, - -1); + ETIR_S_C_STO_QW, + -1); _bfd_vms_output_flush (abfd); } else @@ -2319,20 +2071,20 @@ _bfd_vms_write_tir (abfd, objtype) end_etir_record (abfd); start_etir_record (abfd, section->index, - vaddr, false); + vaddr, FALSE); } _bfd_vms_output_begin (abfd, - ETIR_S_C_STA_PQ, - -1); + ETIR_S_C_STA_PQ, + -1); _bfd_vms_output_long (abfd, - (unsigned long)(sec->index)); + (unsigned long) (sec->index)); _bfd_vms_output_quad (abfd, - ((uquad)(*rptr)->addend - + (uquad)sym->value)); + ((uquad) (*rptr)->addend + + (uquad) sym->value)); _bfd_vms_output_flush (abfd); _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_OFF, - -1); + ETIR_S_C_STO_OFF, + -1); _bfd_vms_output_flush (abfd); } } @@ -2341,37 +2093,33 @@ _bfd_vms_write_tir (abfd, objtype) 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; -#if 0 - vms_output_begin(abfd, ETIR_S_C_STO_HINT_GBL, -1); - vms_output_long(abfd, (unsigned long)(sec->index)); - vms_output_quad(abfd, (uquad)addr); - - vms_output_counted(abfd, _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ_S_C_SYMSIZ)); - vms_output_flush(abfd); -#endif } 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); + vaddr, FALSE); } _bfd_vms_output_begin (abfd, - ETIR_S_C_STC_LP_PSB, - -1); + ETIR_S_C_STC_LP_PSB, + -1); _bfd_vms_output_long (abfd, - (unsigned long)PRIV(vms_linkage_index)); - PRIV(vms_linkage_index) += 2; - _bfd_vms_output_counted (abfd, - _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ_S_C_SYMSIZ)); + (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); } @@ -2379,20 +2127,21 @@ _bfd_vms_write_tir (abfd, objtype) case ALPHA_R_CODEADDR: { - if (_bfd_vms_output_check (abfd, - strlen((char *)sym->name)) - < 0) + 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); + vaddr, FALSE); } _bfd_vms_output_begin (abfd, - ETIR_S_C_STO_CA, - -1); - _bfd_vms_output_counted (abfd, - _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ_S_C_SYMSIZ)); + 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; @@ -2418,51 +2167,52 @@ _bfd_vms_write_tir (abfd, objtype) rptr++; } } - else /* sptr starts after reloc */ + else { - i--; /* check next reloc */ + /* Sptr starts after reloc. */ + i--; + /* Check next reloc. */ rptr++; } - if (i==0) /* all reloc checked */ + if (i == 0) { + /* All reloc checked. */ if (sptr->size > 0) { - sto_imm (abfd, sptr, vaddr, section->index); /* dump rest */ + /* Dump rest. */ + sto_imm (abfd, sptr, vaddr, section->index); vaddr += sptr->size; } break; } - } /* for (;;) */ - } /* if SEC_RELOC */ - else /* no relocs, just dump */ + } + } + else { + /* No relocs, just dump. */ sto_imm (abfd, sptr, vaddr, section->index); vaddr += sptr->size; } sptr = sptr->next; - - } /* while (sptr != 0) */ + } end_etir_record (abfd); - - } /* has_contents */ + } section = section->next; } - _bfd_vms_output_alignment(abfd, 2); + _bfd_vms_output_alignment (abfd, 2); return 0; } - -/* write traceback data for bfd abfd */ +/* Write traceback data for bfd abfd. */ int -_bfd_vms_write_tbt (abfd, objtype) - bfd *abfd ATTRIBUTE_UNUSED; - int objtype ATTRIBUTE_UNUSED; +_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); @@ -2471,13 +2221,11 @@ _bfd_vms_write_tbt (abfd, objtype) return 0; } - -/* write debug info for bfd abfd */ +/* Write debug info for bfd abfd. */ int -_bfd_vms_write_dbg (abfd, objtype) - bfd *abfd ATTRIBUTE_UNUSED; - int objtype ATTRIBUTE_UNUSED; +_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);