Open64: osprey/cygnus/bfd/vms-tir.c Source File

00001 /*
00002  * Copyright 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00003  */
00004 
00005 /* vms-tir.c -- BFD back-end for VAX (openVMS/VAX) and
00006    EVAX (openVMS/Alpha) files.
00007    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005
00008    Free Software Foundation, Inc.
00009 
00010    TIR record handling functions
00011    ETIR record handling functions
00012 
00013    go and read the openVMS linker manual (esp. appendix B)
00014    if you don't know what's going on here :-)
00015 
00016    Written by Klaus K"ampf (kkaempf@rmi.de)
00017 
00018    This program is free software; you can redistribute it and/or modify
00019    it under the terms of the GNU General Public License as published by
00020    the Free Software Foundation; either version 2 of the License, or
00021    (at your option) any later version.
00022 
00023    This program is distributed in the hope that it will be useful,
00024    but WITHOUT ANY WARRANTY; without even the implied warranty of
00025    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00026    GNU General Public License for more details.
00027 
00028    You should have received a copy of the GNU General Public License
00029    along with this program; if not, write to the Free Software
00030    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
00031 
00032 /* The following type abbreviations are used:
00033 
00034   cs  counted string (ascii string with length byte)
00035   by  byte (1 byte)
00036   sh  short (2 byte, 16 bit)
00037   lw  longword (4 byte, 32 bit)
00038   qw  quadword (8 byte, 64 bit)
00039   da  data stream  */
00040 
00041 #include "bfd.h"
00042 #include "sysdep.h"
00043 #include "bfdlink.h"
00044 #include "libbfd.h"
00045 
00046 #include "vms.h"
00047 
00048 static void image_set_ptr
00049   PARAMS ((bfd *abfd, int psect, uquad offset));
00050 static void image_inc_ptr
00051   PARAMS ((bfd *abfd, uquad offset));
00052 static void image_dump
00053   PARAMS ((bfd *abfd, unsigned char *ptr, int size, int offset));
00054 static void image_write_b
00055   PARAMS ((bfd *abfd, unsigned int value));
00056 static void image_write_w
00057   PARAMS ((bfd *abfd, unsigned int value));
00058 static void image_write_l
00059   PARAMS ((bfd *abfd, unsigned long value));
00060 static void image_write_q
00061   PARAMS ((bfd *abfd, uquad value));
00062 static int check_section
00063   PARAMS ((bfd *, int));
00064 static bfd_boolean etir_sta
00065   PARAMS ((bfd *, int, unsigned char *));
00066 static bfd_boolean etir_sto
00067   PARAMS ((bfd *, int, unsigned char *));
00068 static bfd_boolean etir_opr
00069   PARAMS ((bfd *, int, unsigned char *));
00070 static bfd_boolean etir_ctl
00071   PARAMS ((bfd *, int, unsigned char *));
00072 static bfd_boolean etir_stc
00073   PARAMS ((bfd *, int, unsigned char *));
00074 static asection *new_section
00075   PARAMS ((bfd *, int));
00076 static int alloc_section
00077   PARAMS ((bfd *, unsigned int));
00078 static int etir_cmd
00079   PARAMS ((bfd *, int, unsigned char *));
00080 static int analyze_tir
00081   PARAMS ((bfd *, unsigned char *, unsigned int));
00082 static int analyze_etir
00083   PARAMS ((bfd *, unsigned char *, unsigned int));
00084 static unsigned char * tir_opr
00085   PARAMS ((bfd *, unsigned char *));
00086 static const char * tir_cmd_name
00087   PARAMS ((int));
00088 static const char * cmd_name
00089   PARAMS ((int));
00090 
00091 
00092 static int
00093 check_section (abfd, size)
00094      bfd *abfd;
00095      int size;
00096 {
00097   bfd_size_type offset;
00098 
00099   offset = PRIV (image_ptr) - PRIV (image_section)->contents;
00100   if (offset + size > PRIV (image_section)->size)
00101     {
00102       PRIV (image_section)->contents
00103   = bfd_realloc (PRIV (image_section)->contents, offset + size);
00104       if (PRIV (image_section)->contents == 0)
00105   {
00106     (*_bfd_error_handler) (_("No Mem !"));
00107     return -1;
00108   }
00109       PRIV (image_section)->size = offset + size;
00110       PRIV (image_ptr) = PRIV (image_section)->contents + offset;
00111     }
00112 
00113   return 0;
00114 }
00115 
00116 /* Routines to fill sections contents during tir/etir read.  */
00117 
00118 /* Initialize image buffer pointer to be filled.  */
00119 
00120 static void
00121 image_set_ptr (abfd, psect, offset)
00122      bfd *abfd;
00123      int psect;
00124      uquad offset;
00125 {
00126 #if VMS_DEBUG
00127   _bfd_vms_debug (4, "image_set_ptr (%d=%s, %d)\n",
00128       psect, PRIV (sections)[psect]->name, offset);
00129 #endif
00130 
00131   PRIV (image_ptr) = PRIV (sections)[psect]->contents + offset;
00132   PRIV (image_section) = PRIV (sections)[psect];
00133   return;
00134 }
00135 
00136 /* Increment image buffer pointer by offset.  */
00137 
00138 static void
00139 image_inc_ptr (abfd, offset)
00140      bfd *abfd;
00141      uquad offset;
00142 {
00143 #if VMS_DEBUG
00144   _bfd_vms_debug (4, "image_inc_ptr (%d)\n", offset);
00145 #endif
00146 
00147   PRIV (image_ptr) += offset;
00148 
00149   return;
00150 }
00151 
00152 /* Dump multiple bytes to section image.  */
00153 
00154 static void
00155 image_dump (abfd, ptr, size, offset)
00156     bfd *abfd;
00157     unsigned char *ptr;
00158     int size;
00159     int offset ATTRIBUTE_UNUSED;
00160 {
00161 #if VMS_DEBUG
00162   _bfd_vms_debug (8, "image_dump from (%p, %d) to (%p)\n", ptr, size,
00163       PRIV (image_ptr));
00164   _bfd_hexdump (9, ptr, size, offset);
00165 #endif
00166 
00167   if (PRIV (is_vax) && check_section (abfd, size))
00168     return;
00169 
00170   while (size-- > 0)
00171     *PRIV (image_ptr)++ = *ptr++;
00172   return;
00173 }
00174 
00175 /* Write byte to section image.  */
00176 
00177 static void
00178 image_write_b (abfd, value)
00179      bfd *abfd;
00180      unsigned int value;
00181 {
00182 #if VMS_DEBUG
00183   _bfd_vms_debug (6, "image_write_b(%02x)\n", (int) value);
00184 #endif
00185 
00186   if (PRIV (is_vax) && check_section (abfd, 1))
00187     return;
00188 
00189   *PRIV (image_ptr)++ = (value & 0xff);
00190   return;
00191 }
00192 
00193 /* Write 2-byte word to image.  */
00194 
00195 static void
00196 image_write_w (abfd, value)
00197      bfd *abfd;
00198      unsigned int value;
00199 {
00200 #if VMS_DEBUG
00201   _bfd_vms_debug (6, "image_write_w(%04x)\n", (int) value);
00202 #endif
00203 
00204   if (PRIV (is_vax) && check_section (abfd, 2))
00205     return;
00206 
00207   bfd_putl16 ((bfd_vma) value, PRIV (image_ptr));
00208   PRIV (image_ptr) += 2;
00209 
00210   return;
00211 }
00212 
00213 /* Write 4-byte long to image.  */
00214 
00215 static void
00216 image_write_l (abfd, value)
00217      bfd *abfd;
00218      unsigned long value;
00219 {
00220 #if VMS_DEBUG
00221   _bfd_vms_debug (6, "image_write_l (%08lx)\n", value);
00222 #endif
00223 
00224   if (PRIV (is_vax) && check_section (abfd, 4))
00225     return;
00226 
00227   bfd_putl32 ((bfd_vma) value, PRIV (image_ptr));
00228   PRIV (image_ptr) += 4;
00229 
00230   return;
00231 }
00232 
00233 /* Write 8-byte quad to image.  */
00234 
00235 static void
00236 image_write_q (abfd, value)
00237      bfd *abfd;
00238      uquad value;
00239 {
00240 #if VMS_DEBUG
00241   _bfd_vms_debug (6, "image_write_q (%016lx)\n", value);
00242 #endif
00243 
00244   if (PRIV (is_vax) && check_section (abfd, 8))
00245     return;
00246 
00247   bfd_putl64 (value, PRIV (image_ptr));
00248   PRIV (image_ptr) += 8;
00249 
00250   return;
00251 }
00252 
00253 static const char *
00254 cmd_name (cmd)
00255      int cmd;
00256 {
00257   switch (cmd)
00258     {
00259     case ETIR_S_C_STA_GBL: return "ETIR_S_C_STA_GBL";
00260     case ETIR_S_C_STA_PQ: return "ETIR_S_C_STA_PQ";
00261     case ETIR_S_C_STA_LI: return "ETIR_S_C_STA_LI";
00262     case ETIR_S_C_STA_MOD: return "ETIR_S_C_STA_MOD";
00263     case ETIR_S_C_STA_CKARG: return "ETIR_S_C_STA_CKARG";
00264     case ETIR_S_C_STO_B: return "ETIR_S_C_STO_B";
00265     case ETIR_S_C_STO_W: return "ETIR_S_C_STO_W";
00266     case ETIR_S_C_STO_GBL: return "ETIR_S_C_STO_GBL";
00267     case ETIR_S_C_STO_CA: return "ETIR_S_C_STO_CA";
00268     case ETIR_S_C_STO_RB: return "ETIR_S_C_STO_RB";
00269     case ETIR_S_C_STO_AB: return "ETIR_S_C_STO_AB";
00270     case ETIR_S_C_STO_GBL_LW: return "ETIR_S_C_STO_GBL_LW";
00271     case ETIR_S_C_STO_LP_PSB: return "ETIR_S_C_STO_LP_PSB";
00272     case ETIR_S_C_STO_HINT_GBL: return "ETIR_S_C_STO_HINT_GBL";
00273     case ETIR_S_C_STO_HINT_PS: return "ETIR_S_C_STO_HINT_PS";
00274     case ETIR_S_C_OPR_INSV: return "ETIR_S_C_OPR_INSV";
00275     case ETIR_S_C_OPR_USH: return "ETIR_S_C_OPR_USH";
00276     case ETIR_S_C_OPR_ROT: return "ETIR_S_C_OPR_ROT";
00277     case ETIR_S_C_OPR_REDEF: return "ETIR_S_C_OPR_REDEF";
00278     case ETIR_S_C_OPR_DFLIT: return "ETIR_S_C_OPR_DFLIT";
00279     case ETIR_S_C_STC_LP: return "ETIR_S_C_STC_LP";
00280     case ETIR_S_C_STC_GBL: return "ETIR_S_C_STC_GBL";
00281     case ETIR_S_C_STC_GCA: return "ETIR_S_C_STC_GCA";
00282     case ETIR_S_C_STC_PS: return "ETIR_S_C_STC_PS";
00283     case ETIR_S_C_STC_NBH_PS: return "ETIR_S_C_STC_NBH_PS";
00284     case ETIR_S_C_STC_NOP_GBL: return "ETIR_S_C_STC_NOP_GBL";
00285     case ETIR_S_C_STC_NOP_PS: return "ETIR_S_C_STC_NOP_PS";
00286     case ETIR_S_C_STC_BSR_GBL: return "ETIR_S_C_STC_BSR_GBL";
00287     case ETIR_S_C_STC_BSR_PS: return "ETIR_S_C_STC_BSR_PS";
00288     case ETIR_S_C_STC_LDA_GBL: return "ETIR_S_C_STC_LDA_GBL";
00289     case ETIR_S_C_STC_LDA_PS: return "ETIR_S_C_STC_LDA_PS";
00290     case ETIR_S_C_STC_BOH_GBL: return "ETIR_S_C_STC_BOH_GBL";
00291     case ETIR_S_C_STC_BOH_PS: return "ETIR_S_C_STC_BOH_PS";
00292     case ETIR_S_C_STC_NBH_GBL: return "ETIR_S_C_STC_NBH_GBL";
00293 
00294     default:
00295       /* These names have not yet been added to this switch statement.  */
00296       abort ();
00297     }
00298 }
00299 #define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
00300 
00301 /* etir_sta
00302 
00303    vms stack commands
00304 
00305    handle sta_xxx commands in etir section
00306    ptr points to data area in record
00307 
00308    see table B-8 of the openVMS linker manual.  */
00309 
00310 static bfd_boolean
00311 etir_sta (abfd, cmd, ptr)
00312      bfd *abfd;
00313      int cmd;
00314      unsigned char *ptr;
00315 {
00316 
00317 #if VMS_DEBUG
00318   _bfd_vms_debug (5, "etir_sta %d/%x\n", cmd, cmd);
00319   _bfd_hexdump (8, ptr, 16, (int) ptr);
00320 #endif
00321 
00322   switch (cmd)
00323     {
00324       /* stack */
00325 
00326       /* stack global
00327    arg: cs  symbol name
00328 
00329    stack 32 bit value of symbol (high bits set to 0)  */
00330 
00331     case ETIR_S_C_STA_GBL:
00332       {
00333   char *name;
00334   vms_symbol_entry *entry;
00335 
00336   name = _bfd_vms_save_counted_string (ptr);
00337   entry = (vms_symbol_entry *)
00338     bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
00339   if (entry == (vms_symbol_entry *) NULL)
00340     {
00341 #if VMS_DEBUG
00342       _bfd_vms_debug (3, "%s: no symbol \"%s\"\n",
00343           cmd_name (cmd), name);
00344 #endif
00345       _bfd_vms_push (abfd, (uquad) 0, -1);
00346     }
00347   else
00348     {
00349       _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1);
00350     }
00351       }
00352       break;
00353 
00354       /* stack longword
00355    arg: lw  value
00356 
00357    stack 32 bit value, sign extend to 64 bit  */
00358 
00359     case ETIR_S_C_STA_LW:
00360       _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1);
00361       break;
00362 
00363       /* stack global
00364    arg: qw  value
00365 
00366    stack 64 bit value of symbol  */
00367 
00368     case ETIR_S_C_STA_QW:
00369       _bfd_vms_push (abfd, (uquad) bfd_getl64 (ptr), -1);
00370       break;
00371 
00372       /* stack psect base plus quadword offset
00373    arg: lw  section index
00374    qw signed quadword offset (low 32 bits)
00375 
00376    stack qw argument and section index
00377    (see ETIR_S_C_STO_OFF, ETIR_S_C_CTL_SETRB)  */
00378 
00379     case ETIR_S_C_STA_PQ:
00380       {
00381   uquad dummy;
00382   unsigned int psect;
00383 
00384   psect = bfd_getl32 (ptr);
00385   if (psect >= PRIV (section_count))
00386     {
00387       (*_bfd_error_handler) (_("bad section index in %s"),
00388            cmd_name (cmd));
00389       bfd_set_error (bfd_error_bad_value);
00390       return FALSE;
00391     }
00392   dummy = bfd_getl64 (ptr+4);
00393   _bfd_vms_push (abfd, dummy, (int) psect);
00394       }
00395       break;
00396 
00397     case ETIR_S_C_STA_LI:
00398     case ETIR_S_C_STA_MOD:
00399     case ETIR_S_C_STA_CKARG:
00400       (*_bfd_error_handler) (_("unsupported STA cmd %s"), cmd_name (cmd));
00401       return FALSE;
00402       break;
00403 
00404     default:
00405       (*_bfd_error_handler) (_("reserved STA cmd %d"), cmd);
00406       return FALSE;
00407       break;
00408     }
00409 #if VMS_DEBUG
00410   _bfd_vms_debug (5, "etir_sta true\n");
00411 #endif
00412   return TRUE;
00413 }
00414 
00415 /*
00416    etir_sto
00417 
00418    vms store commands
00419 
00420    handle sto_xxx commands in etir section
00421    ptr points to data area in record
00422 
00423    see table B-9 of the openVMS linker manual.  */
00424 
00425 static bfd_boolean
00426 etir_sto (abfd, cmd, ptr)
00427      bfd *abfd;
00428      int cmd;
00429      unsigned char *ptr;
00430 {
00431   uquad dummy;
00432   int psect;
00433 
00434 #if VMS_DEBUG
00435   _bfd_vms_debug (5, "etir_sto %d/%x\n", cmd, cmd);
00436   _bfd_hexdump (8, ptr, 16, (int) ptr);
00437 #endif
00438 
00439   switch (cmd)
00440     {
00441       /* store byte: pop stack, write byte
00442    arg: -  */
00443 
00444     case ETIR_S_C_STO_B:
00445       dummy = _bfd_vms_pop (abfd, &psect);
00446       /* FIXME: check top bits */
00447       image_write_b (abfd, (unsigned int) dummy & 0xff);
00448       break;
00449 
00450       /* store word: pop stack, write word
00451    arg: -  */
00452 
00453     case ETIR_S_C_STO_W:
00454       dummy = _bfd_vms_pop (abfd, &psect);
00455       /* FIXME: check top bits */
00456       image_write_w (abfd, (unsigned int) dummy & 0xffff);
00457       break;
00458 
00459       /* store longword: pop stack, write longword
00460    arg: -  */
00461 
00462     case ETIR_S_C_STO_LW:
00463       dummy = _bfd_vms_pop (abfd, &psect);
00464       dummy += (PRIV (sections)[psect])->vma;
00465       /* FIXME: check top bits.  */
00466       image_write_l (abfd, (unsigned int) dummy & 0xffffffff);
00467       break;
00468 
00469       /* store quadword: pop stack, write quadword
00470    arg: -  */
00471 
00472     case ETIR_S_C_STO_QW:
00473       dummy = _bfd_vms_pop (abfd, &psect);
00474       dummy += (PRIV (sections)[psect])->vma;
00475       image_write_q (abfd, dummy);    /* FIXME: check top bits */
00476       break;
00477 
00478       /* store immediate repeated: pop stack for repeat count
00479    arg: lw  byte count
00480    da data  */
00481 
00482     case ETIR_S_C_STO_IMMR:
00483       {
00484   int size;
00485 
00486   size = bfd_getl32 (ptr);
00487   dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
00488   while (dummy-- > 0)
00489     image_dump (abfd, ptr+4, size, 0);
00490       }
00491       break;
00492 
00493       /* store global: write symbol value
00494    arg: cs  global symbol name.  */
00495 
00496     case ETIR_S_C_STO_GBL:
00497       {
00498   vms_symbol_entry *entry;
00499   char *name;
00500 
00501   name = _bfd_vms_save_counted_string (ptr);
00502   entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
00503                   name, FALSE, FALSE);
00504   if (entry == (vms_symbol_entry *) NULL)
00505     {
00506       (*_bfd_error_handler) (_("%s: no symbol \"%s\""),
00507            cmd_name (cmd), name);
00508       return FALSE;
00509     }
00510   else
00511     /* FIXME, reloc.  */
00512     image_write_q (abfd, (uquad) (entry->symbol->value));
00513       }
00514       break;
00515 
00516       /* store code address: write address of entry point
00517    arg: cs  global symbol name (procedure).  */
00518 
00519     case ETIR_S_C_STO_CA:
00520       {
00521   vms_symbol_entry *entry;
00522   char *name;
00523 
00524   name = _bfd_vms_save_counted_string (ptr);
00525   entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
00526                   name, FALSE, FALSE);
00527   if (entry == (vms_symbol_entry *) NULL)
00528     {
00529       (*_bfd_error_handler) (_("%s: no symbol \"%s\""),
00530            cmd_name (cmd), name);
00531       return FALSE;
00532     }
00533   else
00534     image_write_q (abfd, (uquad) (entry->symbol->value)); /* FIXME, reloc */
00535       }
00536       break;
00537 
00538       /* Store offset to psect: pop stack, add low 32 bits to base of psect
00539    arg: none.  */
00540 
00541     case ETIR_S_C_STO_OFF:
00542       {
00543   uquad q;
00544   int psect1;
00545 
00546   q = _bfd_vms_pop (abfd, &psect1);
00547   q += (PRIV (sections)[psect1])->vma;
00548   image_write_q (abfd, q);
00549       }
00550       break;
00551 
00552       /* Store immediate
00553    arg: lw  count of bytes
00554         da  data.  */
00555 
00556     case ETIR_S_C_STO_IMM:
00557       {
00558   int size;
00559 
00560   size = bfd_getl32 (ptr);
00561   image_dump (abfd, ptr+4, size, 0);
00562       }
00563       break;
00564 
00565       /* This code is 'reserved to digital' according to the openVMS
00566    linker manual, however it is generated by the DEC C compiler
00567    and defined in the include file.
00568    FIXME, since the following is just a guess
00569    store global longword: store 32bit value of symbol
00570    arg: cs  symbol name.  */
00571 
00572     case ETIR_S_C_STO_GBL_LW:
00573       {
00574   vms_symbol_entry *entry;
00575   char *name;
00576 
00577   name = _bfd_vms_save_counted_string (ptr);
00578   entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
00579                   name, FALSE, FALSE);
00580   if (entry == (vms_symbol_entry *) NULL)
00581     {
00582 #if VMS_DEBUG
00583       _bfd_vms_debug (3, "%s: no symbol \"%s\"\n", cmd_name (cmd), name);
00584 #endif
00585       image_write_l (abfd, (unsigned long) 0);  /* FIXME, reloc */
00586     }
00587   else
00588     /* FIXME, reloc.  */
00589     image_write_l (abfd, (unsigned long) (entry->symbol->value));
00590       }
00591       break;
00592 
00593     case ETIR_S_C_STO_RB:
00594     case ETIR_S_C_STO_AB:
00595     case ETIR_S_C_STO_LP_PSB:
00596       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
00597       break;
00598 
00599     case ETIR_S_C_STO_HINT_GBL:
00600     case ETIR_S_C_STO_HINT_PS:
00601       (*_bfd_error_handler) (_("%s: not implemented"), cmd_name (cmd));
00602       break;
00603 
00604     default:
00605       (*_bfd_error_handler) (_("reserved STO cmd %d"), cmd);
00606       break;
00607     }
00608 
00609   return TRUE;
00610 }
00611 
00612 /* Stack operator commands
00613    all 32 bit signed arithmetic
00614    all word just like a stack calculator
00615    arguments are popped from stack, results are pushed on stack
00616 
00617    see table B-10 of the openVMS linker manual.  */
00618 
00619 static bfd_boolean
00620 etir_opr (abfd, cmd, ptr)
00621      bfd *abfd;
00622      int cmd;
00623      unsigned char *ptr ATTRIBUTE_UNUSED;
00624 {
00625   long op1, op2;
00626 
00627 #if VMS_DEBUG
00628   _bfd_vms_debug (5, "etir_opr %d/%x\n", cmd, cmd);
00629   _bfd_hexdump (8, ptr, 16, (int) ptr);
00630 #endif
00631 
00632   switch (cmd)
00633     {
00634     case ETIR_S_C_OPR_NOP:      /* no-op  */
00635       break;
00636 
00637     case ETIR_S_C_OPR_ADD:      /* add  */
00638       op1 = (long) _bfd_vms_pop (abfd, NULL);
00639       op2 = (long) _bfd_vms_pop (abfd, NULL);
00640       _bfd_vms_push (abfd, (uquad) (op1 + op2), -1);
00641       break;
00642 
00643     case ETIR_S_C_OPR_SUB:      /* subtract  */
00644       op1 = (long) _bfd_vms_pop (abfd, NULL);
00645       op2 = (long) _bfd_vms_pop (abfd, NULL);
00646       _bfd_vms_push (abfd, (uquad) (op2 - op1), -1);
00647       break;
00648 
00649     case ETIR_S_C_OPR_MUL:      /* multiply  */
00650       op1 = (long) _bfd_vms_pop (abfd, NULL);
00651       op2 = (long) _bfd_vms_pop (abfd, NULL);
00652       _bfd_vms_push (abfd, (uquad) (op1 * op2), -1);
00653       break;
00654 
00655     case ETIR_S_C_OPR_DIV:      /* divide  */
00656       op1 = (long) _bfd_vms_pop (abfd, NULL);
00657       op2 = (long) _bfd_vms_pop (abfd, NULL);
00658       if (op2 == 0)
00659   _bfd_vms_push (abfd, (uquad) 0, -1);
00660       else
00661   _bfd_vms_push (abfd, (uquad) (op2 / op1), -1);
00662       break;
00663 
00664     case ETIR_S_C_OPR_AND:      /* logical and  */
00665       op1 = (long) _bfd_vms_pop (abfd, NULL);
00666       op2 = (long) _bfd_vms_pop (abfd, NULL);
00667       _bfd_vms_push (abfd, (uquad) (op1 & op2), -1);
00668       break;
00669 
00670     case ETIR_S_C_OPR_IOR:      /* logical inclusive or  */
00671       op1 = (long) _bfd_vms_pop (abfd, NULL);
00672       op2 = (long) _bfd_vms_pop (abfd, NULL);
00673       _bfd_vms_push (abfd, (uquad) (op1 | op2), -1);
00674       break;
00675 
00676     case ETIR_S_C_OPR_EOR:      /* logical exclusive or  */
00677       op1 = (long) _bfd_vms_pop (abfd, NULL);
00678       op2 = (long) _bfd_vms_pop (abfd, NULL);
00679       _bfd_vms_push (abfd, (uquad) (op1 ^ op2), -1);
00680       break;
00681 
00682     case ETIR_S_C_OPR_NEG:      /* negate  */
00683       op1 = (long) _bfd_vms_pop (abfd, NULL);
00684       _bfd_vms_push (abfd, (uquad) (-op1), -1);
00685       break;
00686 
00687     case ETIR_S_C_OPR_COM:      /* complement  */
00688       op1 = (long) _bfd_vms_pop (abfd, NULL);
00689       _bfd_vms_push (abfd, (uquad) (op1 ^ -1L), -1);
00690       break;
00691 
00692     case ETIR_S_C_OPR_ASH:      /* arithmetic shift  */
00693       op1 = (long) _bfd_vms_pop (abfd, NULL);
00694       op2 = (long) _bfd_vms_pop (abfd, NULL);
00695       if (op2 < 0)    /* shift right */
00696   op1 >>= -op2;
00697       else      /* shift left */
00698   op1 <<= op2;
00699       _bfd_vms_push (abfd, (uquad) op1, -1);
00700       break;
00701 
00702     case ETIR_S_C_OPR_INSV:      /* insert field  */
00703       (void) _bfd_vms_pop (abfd, NULL);
00704     case ETIR_S_C_OPR_USH:       /* unsigned shift  */
00705     case ETIR_S_C_OPR_ROT:       /* rotate  */
00706     case ETIR_S_C_OPR_REDEF:     /* Redefine symbol to current location.  */
00707     case ETIR_S_C_OPR_DFLIT:     /* Define a literal.  */
00708       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
00709       break;
00710 
00711     case ETIR_S_C_OPR_SEL:      /* select  */
00712       if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L)
00713   (void) _bfd_vms_pop (abfd, NULL);
00714       else
00715   {
00716     op1 = (long) _bfd_vms_pop (abfd, NULL);
00717     (void) _bfd_vms_pop (abfd, NULL);
00718     _bfd_vms_push (abfd, (uquad) op1, -1);
00719   }
00720       break;
00721 
00722     default:
00723       (*_bfd_error_handler) (_("reserved OPR cmd %d"), cmd);
00724       break;
00725     }
00726 
00727   return TRUE;
00728 }
00729 
00730 /* Control commands.
00731 
00732    See table B-11 of the openVMS linker manual.  */
00733 
00734 static bfd_boolean
00735 etir_ctl (abfd, cmd, ptr)
00736      bfd *abfd;
00737      int cmd;
00738      unsigned char *ptr;
00739 {
00740   uquad  dummy;
00741   int psect;
00742 
00743 #if VMS_DEBUG
00744   _bfd_vms_debug (5, "etir_ctl %d/%x\n", cmd, cmd);
00745   _bfd_hexdump (8, ptr, 16, (int) ptr);
00746 #endif
00747 
00748   switch (cmd)
00749     {
00750       /* set relocation base: pop stack, set image location counter
00751    arg: none.  */
00752 
00753     case ETIR_S_C_CTL_SETRB:
00754       dummy = _bfd_vms_pop (abfd, &psect);
00755       image_set_ptr (abfd, psect, dummy);
00756       break;
00757 
00758       /* augment relocation base: increment image location counter by offset
00759    arg: lw  offset value  */
00760 
00761     case ETIR_S_C_CTL_AUGRB:
00762       dummy = bfd_getl32 (ptr);
00763       image_inc_ptr (abfd, dummy);
00764       break;
00765 
00766       /* define location: pop index, save location counter under index
00767    arg: none.  */
00768 
00769     case ETIR_S_C_CTL_DFLOC:
00770       dummy = _bfd_vms_pop (abfd, NULL);
00771       /* FIXME */
00772       break;
00773 
00774       /* set location: pop index, restore location counter from index
00775    arg: none.  */
00776 
00777     case ETIR_S_C_CTL_STLOC:
00778       dummy = _bfd_vms_pop (abfd, &psect);
00779       /* FIXME */
00780       break;
00781 
00782       /* stack defined location: pop index, push location counter from index
00783    arg: none.  */
00784 
00785     case ETIR_S_C_CTL_STKDL:
00786       dummy = _bfd_vms_pop (abfd, &psect);
00787       /* FIXME */
00788       break;
00789 
00790     default:
00791       (*_bfd_error_handler) (_("reserved CTL cmd %d"), cmd);
00792       break;
00793     }
00794   return TRUE;
00795 }
00796 
00797 /* store conditional commands
00798 
00799    See table B-12 and B-13 of the openVMS linker manual.  */
00800 
00801 static bfd_boolean
00802 etir_stc (abfd, cmd, ptr)
00803      bfd *abfd;
00804      int cmd;
00805      unsigned char *ptr ATTRIBUTE_UNUSED;
00806 {
00807 #if VMS_DEBUG
00808   _bfd_vms_debug (5, "etir_stc %d/%x\n", cmd, cmd);
00809   _bfd_hexdump (8, ptr, 16, (int) ptr);
00810 #endif
00811 
00812   switch (cmd)
00813     {
00814       /* 200 Store-conditional Linkage Pair
00815    arg: none.  */
00816 
00817     case ETIR_S_C_STC_LP:
00818       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
00819       break;
00820 
00821       /* 201 Store-conditional Linkage Pair with Procedure Signature
00822    arg: lw  linkage index
00823     cs  procedure name
00824     by  signature length
00825     da  signature.  */
00826 
00827     case ETIR_S_C_STC_LP_PSB:
00828       image_inc_ptr (abfd, (uquad) 16); /* skip entry,procval */
00829       break;
00830 
00831       /* 202 Store-conditional Address at global address
00832    arg: lw  linkage index
00833     cs  global name.  */
00834 
00835     case ETIR_S_C_STC_GBL:
00836       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
00837       break;
00838 
00839       /* 203 Store-conditional Code Address at global address
00840    arg: lw  linkage index
00841     cs  procedure name.  */
00842 
00843     case ETIR_S_C_STC_GCA:
00844       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
00845       break;
00846 
00847       /* 204 Store-conditional Address at psect + offset
00848    arg: lw  linkage index
00849     lw  psect index
00850     qw  offset.  */
00851 
00852     case ETIR_S_C_STC_PS:
00853       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
00854       break;
00855 
00856       /* 205 Store-conditional NOP at address of global
00857    arg: none.  */
00858 
00859     case ETIR_S_C_STC_NOP_GBL:
00860 
00861       /* 206 Store-conditional NOP at pect + offset
00862    arg: none.  */
00863 
00864     case ETIR_S_C_STC_NOP_PS:
00865 
00866       /* 207 Store-conditional BSR at global address
00867    arg: none.  */
00868 
00869     case ETIR_S_C_STC_BSR_GBL:
00870 
00871       /* 208 Store-conditional BSR at pect + offset
00872    arg: none.  */
00873 
00874     case ETIR_S_C_STC_BSR_PS:
00875 
00876       /* 209 Store-conditional LDA at global address
00877    arg: none.  */
00878 
00879     case ETIR_S_C_STC_LDA_GBL:
00880 
00881       /* 210 Store-conditional LDA at psect + offset
00882    arg: none.  */
00883 
00884     case ETIR_S_C_STC_LDA_PS:
00885 
00886       /* 211 Store-conditional BSR or Hint at global address
00887    arg: none.  */
00888 
00889     case ETIR_S_C_STC_BOH_GBL:
00890 
00891       /* 212 Store-conditional BSR or Hint at pect + offset
00892    arg: none.  */
00893 
00894     case ETIR_S_C_STC_BOH_PS:
00895 
00896       /* 213 Store-conditional NOP,BSR or HINT at global address
00897    arg: none.  */
00898 
00899     case ETIR_S_C_STC_NBH_GBL:
00900 
00901       /* 214 Store-conditional NOP,BSR or HINT at psect + offset
00902    arg: none.  */
00903 
00904     case ETIR_S_C_STC_NBH_PS:
00905       /* FIXME */
00906       break;
00907 
00908     default:
00909 #if VMS_DEBUG
00910       _bfd_vms_debug (3,  "reserved STC cmd %d", cmd);
00911 #endif
00912       break;
00913     }
00914   return TRUE;
00915 }
00916 
00917 static asection *
00918 new_section (abfd, idx)
00919      bfd *abfd ATTRIBUTE_UNUSED;
00920      int idx;
00921 {
00922   asection *section;
00923   char sname[16];
00924   char *name;
00925 
00926 #if VMS_DEBUG
00927   _bfd_vms_debug (5, "new_section %d\n", idx);
00928 #endif
00929   sprintf (sname, SECTION_NAME_TEMPLATE, idx);
00930 
00931   name = bfd_malloc ((bfd_size_type) strlen (sname) + 1);
00932   if (name == 0)
00933     return 0;
00934   strcpy (name, sname);
00935 
00936   section = bfd_malloc ((bfd_size_type) sizeof (asection));
00937   if (section == 0)
00938     {
00939 #if VMS_DEBUG
00940       _bfd_vms_debug (6,  "bfd_make_section (%s) failed", name);
00941 #endif
00942       return 0;
00943     }
00944 
00945   section->size = 0;
00946   section->vma = 0;
00947   section->contents = 0;
00948   section->name = name;
00949   section->index = idx;
00950 
00951   return section;
00952 }
00953 
00954 static int
00955 alloc_section (abfd, idx)
00956      bfd *abfd;
00957      unsigned int idx;
00958 {
00959   bfd_size_type amt;
00960 
00961 #if VMS_DEBUG
00962   _bfd_vms_debug (4, "alloc_section %d\n", idx);
00963 #endif
00964 
00965   amt = idx + 1;
00966   amt *= sizeof (asection *);
00967   PRIV (sections) = (asection **) bfd_realloc (PRIV (sections), amt);
00968   if (PRIV (sections) == 0)
00969     return -1;
00970 
00971   while (PRIV (section_count) <= idx)
00972     {
00973       PRIV (sections)[PRIV (section_count)]
00974   = new_section (abfd, (int) PRIV (section_count));
00975       if (PRIV (sections)[PRIV (section_count)] == 0)
00976   return -1;
00977       PRIV (section_count)++;
00978     }
00979 
00980   return 0;
00981 }
00982 
00983 /* tir_sta
00984 
00985    vax stack commands
00986 
00987    Handle sta_xxx commands in tir section
00988    ptr points to data area in record
00989 
00990    See table 7-3 of the VAX/VMS linker manual.  */
00991 
00992 static unsigned char *
00993 tir_sta (bfd *abfd, unsigned char *ptr)
00994 {
00995   int cmd = *ptr++;
00996 
00997 #if VMS_DEBUG
00998   _bfd_vms_debug (5, "tir_sta %d\n", cmd);
00999 #endif
01000 
01001   switch (cmd)
01002     {
01003       /* stack */
01004     case TIR_S_C_STA_GBL:
01005       /* stack global
01006    arg: cs  symbol name
01007 
01008    stack 32 bit value of symbol (high bits set to 0).  */
01009       {
01010   char *name;
01011   vms_symbol_entry *entry;
01012 
01013   name = _bfd_vms_save_counted_string (ptr);
01014 
01015   entry = _bfd_vms_enter_symbol (abfd, name);
01016   if (entry == (vms_symbol_entry *) NULL)
01017     return 0;
01018 
01019   _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1);
01020   ptr += *ptr + 1;
01021       }
01022       break;
01023 
01024     case TIR_S_C_STA_SB:
01025       /* stack signed byte
01026    arg: by  value
01027 
01028    stack byte value, sign extend to 32 bit.  */
01029       _bfd_vms_push (abfd, (uquad) *ptr++, -1);
01030       break;
01031 
01032     case TIR_S_C_STA_SW:
01033       /* stack signed short word
01034    arg: sh  value
01035 
01036    stack 16 bit value, sign extend to 32 bit.  */
01037       _bfd_vms_push (abfd, (uquad) bfd_getl16 (ptr), -1);
01038       ptr += 2;
01039       break;
01040 
01041     case TIR_S_C_STA_LW:
01042       /* stack signed longword
01043    arg: lw  value
01044 
01045    stack 32 bit value.  */
01046       _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1);
01047       ptr += 4;
01048       break;
01049 
01050     case TIR_S_C_STA_PB:
01051     case TIR_S_C_STA_WPB:
01052       /* stack psect base plus byte offset (word index)
01053    arg: by  section index
01054     (sh section index)
01055     by  signed byte offset.  */
01056       {
01057   unsigned long dummy;
01058   unsigned int psect;
01059 
01060   if (cmd == TIR_S_C_STA_PB)
01061     psect = *ptr++;
01062   else
01063     {
01064       psect = bfd_getl16 (ptr);
01065       ptr += 2;
01066     }
01067 
01068   if (psect >= PRIV (section_count))
01069     alloc_section (abfd, psect);
01070 
01071   dummy = (long) *ptr++;
01072   dummy += (PRIV (sections)[psect])->vma;
01073   _bfd_vms_push (abfd, (uquad) dummy, (int) psect);
01074       }
01075       break;
01076 
01077     case TIR_S_C_STA_PW:
01078     case TIR_S_C_STA_WPW:
01079       /* stack psect base plus word offset (word index)
01080    arg: by  section index
01081     (sh section index)
01082     sh  signed short offset.  */
01083       {
01084   unsigned long dummy;
01085   unsigned int psect;
01086 
01087   if (cmd == TIR_S_C_STA_PW)
01088     psect = *ptr++;
01089   else
01090     {
01091       psect = bfd_getl16 (ptr);
01092       ptr += 2;
01093     }
01094 
01095   if (psect >= PRIV (section_count))
01096     alloc_section (abfd, psect);
01097 
01098   dummy = bfd_getl16 (ptr); ptr+=2;
01099   dummy += (PRIV (sections)[psect])->vma;
01100   _bfd_vms_push (abfd, (uquad) dummy, (int) psect);
01101       }
01102       break;
01103 
01104     case TIR_S_C_STA_PL:
01105     case TIR_S_C_STA_WPL:
01106       /* stack psect base plus long offset (word index)
01107    arg: by  section index
01108     (sh section index)
01109     lw  signed longword offset.  */
01110       {
01111   unsigned long dummy;
01112   unsigned int psect;
01113 
01114   if (cmd == TIR_S_C_STA_PL)
01115     psect = *ptr++;
01116   else
01117     {
01118       psect = bfd_getl16 (ptr);
01119       ptr += 2;
01120     }
01121 
01122   if (psect >= PRIV (section_count))
01123     alloc_section (abfd, psect);
01124 
01125   dummy = bfd_getl32 (ptr); ptr += 4;
01126   dummy += (PRIV (sections)[psect])->vma;
01127   _bfd_vms_push (abfd, (uquad) dummy, (int) psect);
01128       }
01129       break;
01130 
01131     case TIR_S_C_STA_UB:
01132       /* stack unsigned byte
01133    arg: by  value
01134 
01135    stack byte value.  */
01136       _bfd_vms_push (abfd, (uquad) *ptr++, -1);
01137       break;
01138 
01139     case TIR_S_C_STA_UW:
01140       /* stack unsigned short word
01141    arg: sh  value
01142 
01143    stack 16 bit value.  */
01144       _bfd_vms_push (abfd, (uquad) bfd_getl16 (ptr), -1);
01145       ptr += 2;
01146       break;
01147 
01148     case TIR_S_C_STA_BFI:
01149       /* stack byte from image
01150    arg: none.  */
01151       /* FALLTHRU  */
01152     case TIR_S_C_STA_WFI:
01153       /* stack byte from image
01154    arg: none.  */
01155       /* FALLTHRU */
01156     case TIR_S_C_STA_LFI:
01157       /* stack byte from image
01158    arg: none.  */
01159       (*_bfd_error_handler) (_("stack-from-image not implemented"));
01160       return NULL;
01161 
01162     case TIR_S_C_STA_EPM:
01163       /* stack entry point mask
01164    arg: cs  symbol name
01165 
01166    stack (unsigned) entry point mask of symbol
01167    err if symbol is no entry point.  */
01168       {
01169   char *name;
01170   vms_symbol_entry *entry;
01171 
01172   name = _bfd_vms_save_counted_string (ptr);
01173   entry = _bfd_vms_enter_symbol (abfd, name);
01174   if (entry == (vms_symbol_entry *) NULL)
01175     return 0;
01176 
01177   (*_bfd_error_handler) (_("stack-entry-mask not fully implemented"));
01178   _bfd_vms_push (abfd, (uquad) 0, -1);
01179   ptr += *ptr + 1;
01180       }
01181       break;
01182 
01183     case TIR_S_C_STA_CKARG:
01184       /* compare procedure argument
01185    arg: cs  symbol name
01186     by  argument index
01187     da  argument descriptor
01188 
01189    compare argument descriptor with symbol argument (ARG$V_PASSMECH)
01190    and stack TRUE (args match) or FALSE (args dont match) value.  */
01191       (*_bfd_error_handler) (_("PASSMECH not fully implemented"));
01192       _bfd_vms_push (abfd, (uquad) 1, -1);
01193       break;
01194 
01195     case TIR_S_C_STA_LSY:
01196       /* stack local symbol value
01197    arg: sh  environment index
01198     cs  symbol name.  */
01199       {
01200   int envidx;
01201   char *name;
01202   vms_symbol_entry *entry;
01203 
01204   envidx = bfd_getl16 (ptr);
01205   ptr += 2;
01206   name = _bfd_vms_save_counted_string (ptr);
01207   entry = _bfd_vms_enter_symbol (abfd, name);
01208   if (entry == (vms_symbol_entry *) NULL)
01209     return 0;
01210   (*_bfd_error_handler) (_("stack-local-symbol not fully implemented"));
01211   _bfd_vms_push (abfd, (uquad) 0, -1);
01212   ptr += *ptr + 1;
01213       }
01214       break;
01215 
01216     case TIR_S_C_STA_LIT:
01217       /* stack literal
01218    arg: by  literal index
01219 
01220    stack literal.  */
01221       ptr++;
01222       _bfd_vms_push (abfd, (uquad) 0, -1);
01223       (*_bfd_error_handler) (_("stack-literal not fully implemented"));
01224       break;
01225 
01226     case TIR_S_C_STA_LEPM:
01227       /* stack local symbol entry point mask
01228    arg: sh  environment index
01229     cs  symbol name
01230 
01231    stack (unsigned) entry point mask of symbol
01232    err if symbol is no entry point.  */
01233       {
01234   int envidx;
01235   char *name;
01236   vms_symbol_entry *entry;
01237 
01238   envidx = bfd_getl16 (ptr);
01239   ptr += 2;
01240   name = _bfd_vms_save_counted_string (ptr);
01241   entry = _bfd_vms_enter_symbol (abfd, name);
01242   if (entry == (vms_symbol_entry *) NULL)
01243     return 0;
01244   (*_bfd_error_handler) (_("stack-local-symbol-entry-point-mask not fully implemented"));
01245   _bfd_vms_push (abfd, (uquad) 0, -1);
01246   ptr += *ptr + 1;
01247       }
01248       break;
01249 
01250     default:
01251       (*_bfd_error_handler) (_("reserved STA cmd %d"), ptr[-1]);
01252       return NULL;
01253       break;
01254     }
01255 
01256   return ptr;
01257 }
01258 
01259 static const char *
01260 tir_cmd_name (cmd)
01261      int cmd;
01262 {
01263   switch (cmd)
01264     {
01265     case TIR_S_C_STO_RSB: return "TIR_S_C_STO_RSB";
01266     case TIR_S_C_STO_RSW: return "TIR_S_C_STO_RSW";
01267     case TIR_S_C_STO_RL: return "TIR_S_C_STO_RL";
01268     case TIR_S_C_STO_VPS: return "TIR_S_C_STO_VPS";
01269     case TIR_S_C_STO_USB: return "TIR_S_C_STO_USB";
01270     case TIR_S_C_STO_USW: return "TIR_S_C_STO_USW";
01271     case TIR_S_C_STO_RUB: return "TIR_S_C_STO_RUB";
01272     case TIR_S_C_STO_RUW: return "TIR_S_C_STO_RUW";
01273     case TIR_S_C_STO_PIRR: return "TIR_S_C_STO_PIRR";
01274     case TIR_S_C_OPR_INSV: return "TIR_S_C_OPR_INSV";
01275     case TIR_S_C_OPR_DFLIT: return "TIR_S_C_OPR_DFLIT";
01276     case TIR_S_C_OPR_REDEF: return "TIR_S_C_OPR_REDEF";
01277     case TIR_S_C_OPR_ROT: return "TIR_S_C_OPR_ROT";
01278     case TIR_S_C_OPR_USH: return "TIR_S_C_OPR_USH";
01279     case TIR_S_C_OPR_ASH: return "TIR_S_C_OPR_ASH";
01280     case TIR_S_C_CTL_DFLOC: return "TIR_S_C_CTL_DFLOC";
01281     case TIR_S_C_CTL_STLOC: return "TIR_S_C_CTL_STLOC";
01282     case TIR_S_C_CTL_STKDL: return "TIR_S_C_CTL_STKDL";
01283 
01284     default:
01285       /* These strings have not been added yet.  */
01286       abort ();
01287     }
01288 }
01289 
01290 /* tir_sto
01291 
01292    vax store commands
01293 
01294    handle sto_xxx commands in tir section
01295    ptr points to data area in record
01296 
01297    See table 7-4 of the VAX/VMS linker manual.  */
01298 
01299 static unsigned char *
01300 tir_sto (bfd *abfd, unsigned char *ptr)
01301 {
01302   unsigned long dummy;
01303   int size;
01304   int psect;
01305 
01306 #if VMS_DEBUG
01307   _bfd_vms_debug (5, "tir_sto %d\n", *ptr);
01308 #endif
01309 
01310   switch (*ptr++)
01311     {
01312     case TIR_S_C_STO_SB:
01313       /* store signed byte: pop stack, write byte
01314    arg: none.  */
01315       dummy = _bfd_vms_pop (abfd, &psect);
01316       image_write_b (abfd, dummy & 0xff); /* FIXME: check top bits */
01317       break;
01318 
01319     case TIR_S_C_STO_SW:
01320       /* store signed word: pop stack, write word
01321    arg: none.  */
01322       dummy = _bfd_vms_pop (abfd, &psect);
01323       image_write_w (abfd, dummy & 0xffff); /* FIXME: check top bits */
01324       break;
01325 
01326     case TIR_S_C_STO_LW:
01327       /* store longword: pop stack, write longword
01328    arg: none.  */
01329       dummy = _bfd_vms_pop (abfd, &psect);
01330       image_write_l (abfd, dummy & 0xffffffff); /* FIXME: check top bits */
01331       break;
01332 
01333     case TIR_S_C_STO_BD:
01334       /* store byte displaced: pop stack, sub lc+1, write byte
01335    arg: none.  */
01336       dummy = _bfd_vms_pop (abfd, &psect);
01337       dummy -= ((PRIV (sections)[psect])->vma + 1);
01338       image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */
01339       break;
01340 
01341     case TIR_S_C_STO_WD:
01342       /* store word displaced: pop stack, sub lc+2, write word
01343    arg: none.  */
01344       dummy = _bfd_vms_pop (abfd, &psect);
01345       dummy -= ((PRIV (sections)[psect])->vma + 2);
01346       image_write_w (abfd, dummy & 0xffff);/* FIXME: check top bits */
01347       break;
01348 
01349     case TIR_S_C_STO_LD:
01350       /* store long displaced: pop stack, sub lc+4, write long
01351    arg: none.  */
01352       dummy = _bfd_vms_pop (abfd, &psect);
01353       dummy -= ((PRIV (sections)[psect])->vma + 4);
01354       image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */
01355       break;
01356 
01357     case TIR_S_C_STO_LI:
01358       /* store short literal: pop stack, write byte
01359    arg: none.  */
01360       dummy = _bfd_vms_pop (abfd, &psect);
01361       image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */
01362       break;
01363 
01364     case TIR_S_C_STO_PIDR:
01365       /* store position independent data reference: pop stack, write longword
01366    arg: none.
01367    FIXME: incomplete !  */
01368       dummy = _bfd_vms_pop (abfd, &psect);
01369       image_write_l (abfd, dummy & 0xffffffff);
01370       break;
01371 
01372     case TIR_S_C_STO_PICR:
01373       /* store position independent code reference: pop stack, write longword
01374    arg: none.
01375    FIXME: incomplete !  */
01376       dummy = _bfd_vms_pop (abfd, &psect);
01377       image_write_b (abfd, 0x9f);
01378       image_write_l (abfd, dummy & 0xffffffff);
01379       break;
01380 
01381     case TIR_S_C_STO_RIVB:
01382       /* store repeated immediate variable bytes
01383    1-byte count n field followed by n bytes of data
01384    pop stack, write n bytes <stack> times.  */
01385       size = *ptr++;
01386       dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
01387       while (dummy-- > 0L)
01388   image_dump (abfd, ptr, size, 0);
01389       ptr += size;
01390       break;
01391 
01392     case TIR_S_C_STO_B:
01393       /* store byte from top longword.  */
01394       dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
01395       image_write_b (abfd, dummy & 0xff);
01396       break;
01397 
01398     case TIR_S_C_STO_W:
01399       /* store word from top longword.  */
01400       dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
01401       image_write_w (abfd, dummy & 0xffff);
01402       break;
01403 
01404     case TIR_S_C_STO_RB:
01405       /* store repeated byte from top longword.  */
01406       size = (unsigned long) _bfd_vms_pop (abfd, NULL);
01407       dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
01408       while (size-- > 0)
01409   image_write_b (abfd, dummy & 0xff);
01410       break;
01411 
01412     case TIR_S_C_STO_RW:
01413       /* store repeated word from top longword.  */
01414       size = (unsigned long) _bfd_vms_pop (abfd, NULL);
01415       dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
01416       while (size-- > 0)
01417   image_write_w (abfd, dummy & 0xffff);
01418       break;
01419 
01420     case TIR_S_C_STO_RSB:
01421     case TIR_S_C_STO_RSW:
01422     case TIR_S_C_STO_RL:
01423     case TIR_S_C_STO_VPS:
01424     case TIR_S_C_STO_USB:
01425     case TIR_S_C_STO_USW:
01426     case TIR_S_C_STO_RUB:
01427     case TIR_S_C_STO_RUW:
01428     case TIR_S_C_STO_PIRR:
01429       (*_bfd_error_handler) (_("%s: not implemented"), tir_cmd_name (ptr[-1]));
01430       break;
01431 
01432     default:
01433       (*_bfd_error_handler) (_("reserved STO cmd %d"), ptr[-1]);
01434       break;
01435     }
01436 
01437   return ptr;
01438 }
01439 
01440 /* stack operator commands
01441    all 32 bit signed arithmetic
01442    all word just like a stack calculator
01443    arguments are popped from stack, results are pushed on stack
01444 
01445    See table 7-5 of the VAX/VMS linker manual.  */
01446 
01447 static unsigned char *
01448 tir_opr (abfd, ptr)
01449      bfd *abfd;
01450      unsigned char *ptr;
01451 {
01452   long op1, op2;
01453 
01454 #if VMS_DEBUG
01455   _bfd_vms_debug (5, "tir_opr %d\n", *ptr);
01456 #endif
01457 
01458   switch (*ptr++)
01459     {
01460       /* operation */
01461     case TIR_S_C_OPR_NOP: /* no-op */
01462       break;
01463 
01464     case TIR_S_C_OPR_ADD: /* add */
01465       op1 = (long) _bfd_vms_pop (abfd, NULL);
01466       op2 = (long) _bfd_vms_pop (abfd, NULL);
01467       _bfd_vms_push (abfd, (uquad) (op1 + op2), -1);
01468       break;
01469 
01470     case TIR_S_C_OPR_SUB: /* subtract */
01471       op1 = (long) _bfd_vms_pop (abfd, NULL);
01472       op2 = (long) _bfd_vms_pop (abfd, NULL);
01473       _bfd_vms_push (abfd, (uquad) (op2 - op1), -1);
01474       break;
01475 
01476     case TIR_S_C_OPR_MUL: /* multiply */
01477       op1 = (long) _bfd_vms_pop (abfd, NULL);
01478       op2 = (long) _bfd_vms_pop (abfd, NULL);
01479       _bfd_vms_push (abfd, (uquad) (op1 * op2), -1);
01480       break;
01481 
01482     case TIR_S_C_OPR_DIV: /* divide */
01483       op1 = (long) _bfd_vms_pop (abfd, NULL);
01484       op2 = (long) _bfd_vms_pop (abfd, NULL);
01485       if (op2 == 0)
01486   _bfd_vms_push (abfd, (uquad) 0, -1);
01487       else
01488   _bfd_vms_push (abfd, (uquad) (op2 / op1), -1);
01489       break;
01490 
01491     case TIR_S_C_OPR_AND: /* logical and */
01492       op1 = (long) _bfd_vms_pop (abfd, NULL);
01493       op2 = (long) _bfd_vms_pop (abfd, NULL);
01494       _bfd_vms_push (abfd, (uquad) (op1 & op2), -1);
01495       break;
01496 
01497     case TIR_S_C_OPR_IOR: /* logical inclusive or */
01498       op1 = (long) _bfd_vms_pop (abfd, NULL);
01499       op2 = (long) _bfd_vms_pop (abfd, NULL);
01500       _bfd_vms_push (abfd, (uquad) (op1 | op2), -1);
01501       break;
01502 
01503     case TIR_S_C_OPR_EOR: /* logical exclusive or */
01504       op1 = (long) _bfd_vms_pop (abfd, NULL);
01505       op2 = (long) _bfd_vms_pop (abfd, NULL);
01506       _bfd_vms_push (abfd, (uquad) (op1 ^ op2), -1);
01507       break;
01508 
01509     case TIR_S_C_OPR_NEG: /* negate */
01510       op1 = (long) _bfd_vms_pop (abfd, NULL);
01511       _bfd_vms_push (abfd, (uquad) (-op1), -1);
01512       break;
01513 
01514     case TIR_S_C_OPR_COM: /* complement */
01515       op1 = (long) _bfd_vms_pop (abfd, NULL);
01516       _bfd_vms_push (abfd, (uquad) (op1 ^ -1L), -1);
01517       break;
01518 
01519     case TIR_S_C_OPR_INSV: /* insert field */
01520       (void) _bfd_vms_pop (abfd, NULL);
01521       (*_bfd_error_handler)  (_("%s: not fully implemented"),
01522             tir_cmd_name (ptr[-1]));
01523       break;
01524 
01525     case TIR_S_C_OPR_ASH: /* arithmetic shift */
01526       op1 = (long) _bfd_vms_pop (abfd, NULL);
01527       op2 = (long) _bfd_vms_pop (abfd, NULL);
01528       if (HIGHBIT (op1))  /* shift right */
01529   op2 >>= op1;
01530       else      /* shift left */
01531   op2 <<= op1;
01532       _bfd_vms_push (abfd, (uquad) op2, -1);
01533       (*_bfd_error_handler)  (_("%s: not fully implemented"),
01534             tir_cmd_name (ptr[-1]));
01535       break;
01536 
01537     case TIR_S_C_OPR_USH: /* unsigned shift */
01538       op1 = (long) _bfd_vms_pop (abfd, NULL);
01539       op2 = (long) _bfd_vms_pop (abfd, NULL);
01540       if (HIGHBIT (op1))  /* shift right */
01541   op2 >>= op1;
01542       else      /* shift left */
01543   op2 <<= op1;
01544       _bfd_vms_push (abfd, (uquad) op2, -1);
01545       (*_bfd_error_handler)  (_("%s: not fully implemented"),
01546             tir_cmd_name (ptr[-1]));
01547       break;
01548 
01549     case TIR_S_C_OPR_ROT: /* rotate */
01550       op1 = (long) _bfd_vms_pop (abfd, NULL);
01551       op2 = (long) _bfd_vms_pop (abfd, NULL);
01552       if (HIGHBIT (0))  /* shift right */
01553   op2 >>= op1;
01554       else    /* shift left */
01555   op2 <<= op1;
01556       _bfd_vms_push (abfd, (uquad) op2, -1);
01557       (*_bfd_error_handler)  (_("%s: not fully implemented"),
01558             tir_cmd_name (ptr[-1]));
01559       break;
01560 
01561     case TIR_S_C_OPR_SEL: /* select */
01562       if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L)
01563   (void) _bfd_vms_pop (abfd, NULL);
01564       else
01565   {
01566     op1 = (long) _bfd_vms_pop (abfd, NULL);
01567     (void) _bfd_vms_pop (abfd, NULL);
01568     _bfd_vms_push (abfd, (uquad) op1, -1);
01569   }
01570       break;
01571 
01572     case TIR_S_C_OPR_REDEF: /* Redefine symbol to current location.  */
01573     case TIR_S_C_OPR_DFLIT: /* Define a literal.  */
01574       (*_bfd_error_handler) (_("%s: not supported"),
01575            tir_cmd_name (ptr[-1]));
01576       break;
01577 
01578     default:
01579       (*_bfd_error_handler) (_("reserved OPR cmd %d"), ptr[-1]);
01580       break;
01581     }
01582 
01583   return ptr;
01584 }
01585 
01586 /* control commands
01587 
01588    See table 7-6 of the VAX/VMS linker manual.  */
01589 
01590 static unsigned char *
01591 tir_ctl (bfd *abfd, unsigned char *ptr)
01592 {
01593   unsigned long dummy;
01594   unsigned int psect;
01595 
01596 #if VMS_DEBUG
01597   _bfd_vms_debug (5, "tir_ctl %d\n", *ptr);
01598 #endif
01599 
01600   switch (*ptr++)
01601     {
01602     case TIR_S_C_CTL_SETRB:
01603       /* Set relocation base: pop stack, set image location counter
01604    arg: none.  */
01605       dummy = _bfd_vms_pop (abfd, (int *) &psect);
01606       if (psect >= PRIV (section_count))
01607   alloc_section (abfd, psect);
01608       image_set_ptr (abfd, (int) psect, (uquad) dummy);
01609       break;
01610 
01611     case TIR_S_C_CTL_AUGRB:
01612       /* Augment relocation base: increment image location counter by offset
01613    arg: lw  offset value.  */
01614       dummy = bfd_getl32 (ptr);
01615       image_inc_ptr (abfd, (uquad) dummy);
01616       break;
01617 
01618     case TIR_S_C_CTL_DFLOC:
01619       /* Define location: pop index, save location counter under index
01620    arg: none.  */
01621       dummy = _bfd_vms_pop (abfd, NULL);
01622       (*_bfd_error_handler) (_("%s: not fully implemented"),
01623            tir_cmd_name (ptr[-1]));
01624       break;
01625 
01626     case TIR_S_C_CTL_STLOC:
01627       /* Set location: pop index, restore location counter from index
01628    arg: none.  */
01629       dummy = _bfd_vms_pop (abfd, (int *) &psect);
01630       (*_bfd_error_handler) (_("%s: not fully implemented"),
01631            tir_cmd_name (ptr[-1]));
01632       break;
01633 
01634     case TIR_S_C_CTL_STKDL:
01635       /* Stack defined location: pop index, push location counter from index
01636    arg: none.  */
01637       dummy = _bfd_vms_pop (abfd, (int *) &psect);
01638       (*_bfd_error_handler) (_("%s: not fully implemented"),
01639            tir_cmd_name (ptr[-1]));
01640       break;
01641 
01642     default:
01643       (*_bfd_error_handler) (_("reserved CTL cmd %d"), ptr[-1]);
01644       break;
01645     }
01646   return ptr;
01647 }
01648 
01649 /* Handle command from TIR section.  */
01650 
01651 static unsigned char *
01652 tir_cmd (bfd *abfd, unsigned char *ptr)
01653 {
01654   struct
01655   {
01656     int mincod;
01657     int maxcod;
01658     unsigned char * (*explain) (bfd *, unsigned char *);
01659   }
01660   tir_table[] =
01661   {
01662     { 0,     TIR_S_C_MAXSTACOD, tir_sta },
01663     { TIR_S_C_MINSTOCOD, TIR_S_C_MAXSTOCOD, tir_sto },
01664     { TIR_S_C_MINOPRCOD, TIR_S_C_MAXOPRCOD, tir_opr },
01665     { TIR_S_C_MINCTLCOD, TIR_S_C_MAXCTLCOD, tir_ctl },
01666     { -1, -1, NULL }
01667   };
01668   int i = 0;
01669 
01670 #if VMS_DEBUG
01671   _bfd_vms_debug (4, "tir_cmd %d/%x\n", *ptr, *ptr);
01672   _bfd_hexdump (8, ptr, 16, (int) ptr);
01673 #endif
01674 
01675   if (*ptr & 0x80)        /* store immediate */
01676     {
01677       i = 128 - (*ptr++ & 0x7f);
01678       image_dump (abfd, ptr, i, 0);
01679       ptr += i;
01680     }
01681   else
01682     {
01683       while (tir_table[i].mincod >= 0)
01684   {
01685     if ( (tir_table[i].mincod <= *ptr)
01686          && (*ptr <= tir_table[i].maxcod))
01687       {
01688         ptr = tir_table[i].explain (abfd, ptr);
01689         break;
01690       }
01691     i++;
01692   }
01693       if (tir_table[i].mincod < 0)
01694   {
01695     (*_bfd_error_handler) (_("obj code %d not found"), *ptr);
01696     ptr = 0;
01697   }
01698     }
01699 
01700   return ptr;
01701 }
01702 
01703 /* Handle command from ETIR section.  */
01704 
01705 static int
01706 etir_cmd (abfd, cmd, ptr)
01707      bfd *abfd;
01708      int cmd;
01709      unsigned char *ptr;
01710 {
01711   static struct
01712   {
01713     int mincod;
01714     int maxcod;
01715     bfd_boolean (*explain) PARAMS ((bfd *, int, unsigned char *));
01716   }
01717   etir_table[] =
01718   {
01719     { ETIR_S_C_MINSTACOD, ETIR_S_C_MAXSTACOD, etir_sta },
01720     { ETIR_S_C_MINSTOCOD, ETIR_S_C_MAXSTOCOD, etir_sto },
01721     { ETIR_S_C_MINOPRCOD, ETIR_S_C_MAXOPRCOD, etir_opr },
01722     { ETIR_S_C_MINCTLCOD, ETIR_S_C_MAXCTLCOD, etir_ctl },
01723     { ETIR_S_C_MINSTCCOD, ETIR_S_C_MAXSTCCOD, etir_stc },
01724     { -1, -1, NULL }
01725   };
01726 
01727   int i = 0;
01728 
01729 #if VMS_DEBUG
01730   _bfd_vms_debug (4, "etir_cmd %d/%x\n", cmd, cmd);
01731   _bfd_hexdump (8, ptr, 16, (int) ptr);
01732 #endif
01733 
01734   while (etir_table[i].mincod >= 0)
01735     {
01736       if ( (etir_table[i].mincod <= cmd)
01737      && (cmd <= etir_table[i].maxcod))
01738   {
01739     if (!etir_table[i].explain (abfd, cmd, ptr))
01740       return -1;
01741     break;
01742   }
01743       i++;
01744     }
01745 
01746 #if VMS_DEBUG
01747   _bfd_vms_debug (4, "etir_cmd: = 0\n");
01748 #endif
01749   return 0;
01750 }
01751 
01752 /* Text Information and Relocation Records (OBJ$C_TIR)
01753    handle tir record.  */
01754 
01755 static int
01756 analyze_tir (abfd, ptr, length)
01757      bfd *abfd;
01758      unsigned char *ptr;
01759      unsigned int length;
01760 {
01761   unsigned char *maxptr;
01762 
01763 #if VMS_DEBUG
01764   _bfd_vms_debug (3, "analyze_tir: %d bytes\n", length);
01765 #endif
01766 
01767   maxptr = ptr + length;
01768 
01769   while (ptr < maxptr)
01770     {
01771       ptr = tir_cmd (abfd, ptr);
01772       if (ptr == 0)
01773   return -1;
01774     }
01775 
01776   return 0;
01777 }
01778 
01779 /* Text Information and Relocation Records (EOBJ$C_ETIR)
01780    handle etir record.  */
01781 
01782 static int
01783 analyze_etir (abfd, ptr, length)
01784      bfd *abfd;
01785      unsigned char *ptr;
01786      unsigned int length;
01787 {
01788   int cmd;
01789   unsigned char *maxptr;
01790   int result = 0;
01791 
01792 #if VMS_DEBUG
01793   _bfd_vms_debug (3, "analyze_etir: %d bytes\n", length);
01794 #endif
01795 
01796   maxptr = ptr + length;
01797 
01798   while (ptr < maxptr)
01799     {
01800       cmd = bfd_getl16 (ptr);
01801       length = bfd_getl16 (ptr + 2);
01802       result = etir_cmd (abfd, cmd, ptr+4);
01803       if (result != 0)
01804   break;
01805       ptr += length;
01806     }
01807 
01808 #if VMS_DEBUG
01809   _bfd_vms_debug (3, "analyze_etir: = %d\n", result);
01810 #endif
01811 
01812   return result;
01813 }
01814 
01815 /* Process ETIR record
01816    Return 0 on success, -1 on error.  */
01817 
01818 int
01819 _bfd_vms_slurp_tir (abfd, objtype)
01820      bfd *abfd;
01821      int objtype;
01822 {
01823   int result;
01824 
01825 #if VMS_DEBUG
01826   _bfd_vms_debug (2, "TIR/ETIR\n");
01827 #endif
01828 
01829   switch (objtype)
01830     {
01831     case EOBJ_S_C_ETIR:
01832       PRIV (vms_rec) += 4;  /* skip type, size */
01833       PRIV (rec_size) -= 4;
01834       result = analyze_etir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size));
01835       break;
01836     case OBJ_S_C_TIR:
01837       PRIV (vms_rec) += 1;  /* skip type */
01838       PRIV (rec_size) -= 1;
01839       result = analyze_tir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size));
01840       break;
01841     default:
01842       result = -1;
01843       break;
01844     }
01845 
01846   return result;
01847 }
01848 
01849 /* Process EDBG record
01850    Return 0 on success, -1 on error
01851 
01852    Not implemented yet.  */
01853 
01854 int
01855 _bfd_vms_slurp_dbg (abfd, objtype)
01856      bfd *abfd;
01857      int objtype ATTRIBUTE_UNUSED;
01858 {
01859 #if VMS_DEBUG
01860   _bfd_vms_debug (2, "DBG/EDBG\n");
01861 #endif
01862 
01863   abfd->flags |= (HAS_DEBUG | HAS_LINENO);
01864   return 0;
01865 }
01866 
01867 /* Process ETBT record
01868    Return 0 on success, -1 on error
01869 
01870    Not implemented yet.  */
01871 
01872 int
01873 _bfd_vms_slurp_tbt (abfd, objtype)
01874      bfd *abfd ATTRIBUTE_UNUSED;
01875      int objtype ATTRIBUTE_UNUSED;
01876 {
01877 #if VMS_DEBUG
01878   _bfd_vms_debug (2, "TBT/ETBT\n");
01879 #endif
01880 
01881   return 0;
01882 }
01883 
01884 /* Process LNK record
01885    Return 0 on success, -1 on error
01886 
01887    Not implemented yet.  */
01888 
01889 int
01890 _bfd_vms_slurp_lnk (abfd, objtype)
01891      bfd *abfd ATTRIBUTE_UNUSED;
01892      int objtype ATTRIBUTE_UNUSED;
01893 {
01894 #if VMS_DEBUG
01895   _bfd_vms_debug (2, "LNK\n");
01896 #endif
01897 
01898   return 0;
01899 }
01900 
01901 /* WRITE ETIR SECTION
01902 
01903    This is still under construction and therefore not documented.  */
01904 
01905 static void start_etir_record
01906   PARAMS ((bfd *abfd, int index, uquad offset, bfd_boolean justoffset));
01907 static void sto_imm
01908   PARAMS ((bfd *abfd, vms_section *sptr, bfd_vma vaddr, int index));
01909 static void end_etir_record
01910   PARAMS ((bfd *abfd));
01911 
01912 static void
01913 sto_imm (abfd, sptr, vaddr, index)
01914      bfd *abfd;
01915      vms_section *sptr;
01916      bfd_vma vaddr;
01917      int index;
01918 {
01919   int size;
01920   int ssize;
01921   unsigned char *cptr;
01922 
01923 #if VMS_DEBUG
01924   _bfd_vms_debug (8, "sto_imm %d bytes\n", sptr->size);
01925   _bfd_hexdump (9, sptr->contents, (int) sptr->size, (int) vaddr);
01926 #endif
01927 
01928   ssize = sptr->size;
01929   cptr = sptr->contents;
01930 
01931   while (ssize > 0)
01932     {
01933       size = ssize;       /* try all the rest */
01934 
01935       if (_bfd_vms_output_check (abfd, size) < 0)
01936   {         /* doesn't fit, split ! */
01937     end_etir_record (abfd);
01938     start_etir_record (abfd, index, vaddr, FALSE);
01939     size = _bfd_vms_output_check (abfd, 0); /* get max size */
01940     if (size > ssize)     /* more than what's left ? */
01941       size = ssize;
01942   }
01943 
01944       _bfd_vms_output_begin (abfd, ETIR_S_C_STO_IMM, -1);
01945       _bfd_vms_output_long (abfd, (unsigned long) (size));
01946       _bfd_vms_output_dump (abfd, cptr, size);
01947       _bfd_vms_output_flush (abfd);
01948 
01949 #if VMS_DEBUG
01950       _bfd_vms_debug (10, "dumped %d bytes\n", size);
01951       _bfd_hexdump (10, cptr, (int) size, (int) vaddr);
01952 #endif
01953 
01954       vaddr += size;
01955       ssize -= size;
01956       cptr += size;
01957     }
01958 }
01959 
01960 /* Start ETIR record for section #index at virtual addr offset.  */
01961 
01962 static void
01963 start_etir_record (abfd, index, offset, justoffset)
01964     bfd *abfd;
01965     int index;
01966     uquad offset;
01967     bfd_boolean justoffset;
01968 {
01969   if (!justoffset)
01970     {
01971       _bfd_vms_output_begin (abfd, EOBJ_S_C_ETIR, -1);  /* one ETIR per section */
01972       _bfd_vms_output_push (abfd);
01973     }
01974 
01975   _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1);  /* push start offset */
01976   _bfd_vms_output_long (abfd, (unsigned long) index);
01977   _bfd_vms_output_quad (abfd, (uquad) offset);
01978   _bfd_vms_output_flush (abfd);
01979 
01980   _bfd_vms_output_begin (abfd, ETIR_S_C_CTL_SETRB, -1); /* start = pop () */
01981   _bfd_vms_output_flush (abfd);
01982 }
01983 
01984 /* End etir record.  */
01985 
01986 static void
01987 end_etir_record (abfd)
01988     bfd *abfd;
01989 {
01990   _bfd_vms_output_pop (abfd);
01991   _bfd_vms_output_end (abfd);
01992 }
01993 
01994 /* Write section contents for bfd abfd.  */
01995 
01996 int
01997 _bfd_vms_write_tir (abfd, objtype)
01998      bfd *abfd;
01999      int objtype ATTRIBUTE_UNUSED;
02000 {
02001   asection *section;
02002   vms_section *sptr;
02003   int nextoffset;
02004 
02005 #if VMS_DEBUG
02006   _bfd_vms_debug (2, "vms_write_tir (%p, %d)\n", abfd, objtype);
02007 #endif
02008 
02009   _bfd_vms_output_alignment (abfd, 4);
02010 
02011   nextoffset = 0;
02012   PRIV (vms_linkage_index) = 1;
02013 
02014   /* Dump all other sections.  */
02015 
02016   section = abfd->sections;
02017 
02018   while (section != NULL)
02019     {
02020 
02021 #if VMS_DEBUG
02022       _bfd_vms_debug (4, "writing %d. section '%s' (%d bytes)\n",
02023           section->index, section->name,
02024           (int) (section->size));
02025 #endif
02026 
02027       if (section->flags & SEC_RELOC)
02028   {
02029     int i;
02030 
02031     if ((i = section->reloc_count) <= 0)
02032       {
02033         (*_bfd_error_handler) (_("SEC_RELOC with no relocs in section %s"),
02034              section->name);
02035       }
02036 #if VMS_DEBUG
02037     else
02038       {
02039         arelent **rptr;
02040         _bfd_vms_debug (4, "%d relocations:\n", i);
02041         rptr = section->orelocation;
02042         while (i-- > 0)
02043     {
02044       _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, addr %08lx, off %08lx, len %d: %s\n",
02045           (*(*rptr)->sym_ptr_ptr)->name,
02046           (*(*rptr)->sym_ptr_ptr)->section->name,
02047           (long) (*(*rptr)->sym_ptr_ptr)->value,
02048           (*rptr)->address, (*rptr)->addend,
02049           bfd_get_reloc_size ((*rptr)->howto),
02050           (*rptr)->howto->name);
02051       rptr++;
02052     }
02053       }
02054 #endif
02055   }
02056 
02057       if ((section->flags & SEC_HAS_CONTENTS)
02058     && (! bfd_is_com_section (section)))
02059   {
02060     bfd_vma vaddr;    /* Virtual addr in section.  */
02061 
02062     sptr = _bfd_get_vms_section (abfd, section->index);
02063     if (sptr == NULL)
02064       {
02065         bfd_set_error (bfd_error_no_contents);
02066         return -1;
02067       }
02068 
02069     vaddr = (bfd_vma) (sptr->offset);
02070 
02071     start_etir_record (abfd, section->index, (uquad) sptr->offset,
02072            FALSE);
02073 
02074     while (sptr != NULL)  /* one STA_PQ, CTL_SETRB per vms_section */
02075       {
02076 
02077         if (section->flags & SEC_RELOC) /* check for relocs */
02078     {
02079       arelent **rptr = section->orelocation;
02080       int i = section->reloc_count;
02081 
02082       for (;;)
02083         {
02084           bfd_size_type addr = (*rptr)->address;
02085           bfd_size_type len = bfd_get_reloc_size ((*rptr)->howto);
02086           if (sptr->offset < addr)  /* sptr starts before reloc */
02087       {
02088         bfd_size_type before = addr - sptr->offset;
02089         if (sptr->size <= before) /* complete before */
02090           {
02091             sto_imm (abfd, sptr, vaddr, section->index);
02092             vaddr += sptr->size;
02093             break;
02094           }
02095         else        /* partly before */
02096           {
02097             int after = sptr->size - before;
02098             sptr->size = before;
02099             sto_imm (abfd, sptr, vaddr, section->index);
02100             vaddr += sptr->size;
02101             sptr->contents += before;
02102             sptr->offset += before;
02103             sptr->size = after;
02104           }
02105       }
02106           else if (sptr->offset == addr) /* sptr starts at reloc */
02107       {
02108         asymbol *sym = *(*rptr)->sym_ptr_ptr;
02109         asection *sec = sym->section;
02110 
02111         switch ((*rptr)->howto->type)
02112           {
02113           case ALPHA_R_IGNORE:
02114             break;
02115 
02116           case ALPHA_R_REFLONG:
02117             {
02118         if (bfd_is_und_section (sym->section))
02119           {
02120             int slen = strlen ((char *) sym->name);
02121             char *hash;
02122 
02123             if (_bfd_vms_output_check (abfd, slen) < 0)
02124               {
02125           end_etir_record (abfd);
02126           start_etir_record (abfd,
02127                  section->index,
02128                  vaddr, FALSE);
02129               }
02130             _bfd_vms_output_begin (abfd,
02131                  ETIR_S_C_STO_GBL_LW,
02132                  -1);
02133             hash = (_bfd_vms_length_hash_symbol
02134               (abfd, sym->name, EOBJ_S_C_SYMSIZ));
02135             _bfd_vms_output_counted (abfd, hash);
02136             _bfd_vms_output_flush (abfd);
02137           }
02138         else if (bfd_is_abs_section (sym->section))
02139           {
02140             if (_bfd_vms_output_check (abfd, 16) < 0)
02141               {
02142           end_etir_record (abfd);
02143           start_etir_record (abfd,
02144                  section->index,
02145                  vaddr, FALSE);
02146               }
02147             _bfd_vms_output_begin (abfd,
02148                  ETIR_S_C_STA_LW,
02149                  -1);
02150             _bfd_vms_output_quad (abfd,
02151                 (uquad) sym->value);
02152             _bfd_vms_output_flush (abfd);
02153             _bfd_vms_output_begin (abfd,
02154                  ETIR_S_C_STO_LW,
02155                  -1);
02156             _bfd_vms_output_flush (abfd);
02157           }
02158         else
02159           {
02160             if (_bfd_vms_output_check (abfd, 32) < 0)
02161               {
02162           end_etir_record (abfd);
02163           start_etir_record (abfd,
02164                  section->index,
02165                  vaddr, FALSE);
02166               }
02167             _bfd_vms_output_begin (abfd,
02168                  ETIR_S_C_STA_PQ,
02169                  -1);
02170             _bfd_vms_output_long (abfd,
02171                 (unsigned long) (sec->index));
02172             _bfd_vms_output_quad (abfd,
02173                 ((uquad) (*rptr)->addend
02174                  + (uquad) sym->value));
02175             _bfd_vms_output_flush (abfd);
02176             _bfd_vms_output_begin (abfd,
02177                  ETIR_S_C_STO_LW,
02178                  -1);
02179             _bfd_vms_output_flush (abfd);
02180           }
02181             }
02182             break;
02183 
02184           case ALPHA_R_REFQUAD:
02185             {
02186         if (bfd_is_und_section (sym->section))
02187           {
02188             int slen = strlen ((char *) sym->name);
02189             char *hash;
02190             if (_bfd_vms_output_check (abfd, slen) < 0)
02191               {
02192           end_etir_record (abfd);
02193           start_etir_record (abfd,
02194                  section->index,
02195                  vaddr, FALSE);
02196               }
02197             _bfd_vms_output_begin (abfd,
02198                  ETIR_S_C_STO_GBL,
02199                  -1);
02200             hash = (_bfd_vms_length_hash_symbol
02201               (abfd, sym->name, EOBJ_S_C_SYMSIZ));
02202             _bfd_vms_output_counted (abfd, hash);
02203             _bfd_vms_output_flush (abfd);
02204           }
02205         else if (bfd_is_abs_section (sym->section))
02206           {
02207             if (_bfd_vms_output_check (abfd, 16) < 0)
02208               {
02209           end_etir_record (abfd);
02210           start_etir_record (abfd,
02211                  section->index,
02212                  vaddr, FALSE);
02213               }
02214             _bfd_vms_output_begin (abfd,
02215                  ETIR_S_C_STA_QW,
02216                  -1);
02217             _bfd_vms_output_quad (abfd,
02218                 (uquad) sym->value);
02219             _bfd_vms_output_flush (abfd);
02220             _bfd_vms_output_begin (abfd,
02221                  ETIR_S_C_STO_QW,
02222                  -1);
02223             _bfd_vms_output_flush (abfd);
02224           }
02225         else
02226           {
02227             if (_bfd_vms_output_check (abfd, 32) < 0)
02228               {
02229           end_etir_record (abfd);
02230           start_etir_record (abfd,
02231                  section->index,
02232                  vaddr, FALSE);
02233               }
02234             _bfd_vms_output_begin (abfd,
02235                  ETIR_S_C_STA_PQ,
02236                  -1);
02237             _bfd_vms_output_long (abfd,
02238                 (unsigned long) (sec->index));
02239             _bfd_vms_output_quad (abfd,
02240                 ((uquad) (*rptr)->addend
02241                  + (uquad) sym->value));
02242             _bfd_vms_output_flush (abfd);
02243             _bfd_vms_output_begin (abfd,
02244                  ETIR_S_C_STO_OFF,
02245                  -1);
02246             _bfd_vms_output_flush (abfd);
02247           }
02248             }
02249             break;
02250 
02251           case ALPHA_R_HINT:
02252             {
02253         int hint_size;
02254         char *hash ATTRIBUTE_UNUSED;
02255 
02256         hint_size = sptr->size;
02257         sptr->size = len;
02258         sto_imm (abfd, sptr, vaddr, section->index);
02259         sptr->size = hint_size;
02260             }
02261             break;
02262           case ALPHA_R_LINKAGE:
02263             {
02264         char *hash;
02265 
02266         if (_bfd_vms_output_check (abfd, 64) < 0)
02267           {
02268             end_etir_record (abfd);
02269             start_etir_record (abfd, section->index,
02270                    vaddr, FALSE);
02271           }
02272         _bfd_vms_output_begin (abfd,
02273                    ETIR_S_C_STC_LP_PSB,
02274                    -1);
02275         _bfd_vms_output_long (abfd,
02276                   (unsigned long) PRIV (vms_linkage_index));
02277         PRIV (vms_linkage_index) += 2;
02278         hash = (_bfd_vms_length_hash_symbol
02279           (abfd, sym->name, EOBJ_S_C_SYMSIZ));
02280         _bfd_vms_output_counted (abfd, hash);
02281         _bfd_vms_output_byte (abfd, 0);
02282         _bfd_vms_output_flush (abfd);
02283             }
02284             break;
02285 
02286           case ALPHA_R_CODEADDR:
02287             {
02288         int slen = strlen ((char *) sym->name);
02289         char *hash;
02290         if (_bfd_vms_output_check (abfd, slen) < 0)
02291           {
02292             end_etir_record (abfd);
02293             start_etir_record (abfd,
02294                    section->index,
02295                    vaddr, FALSE);
02296           }
02297         _bfd_vms_output_begin (abfd,
02298                    ETIR_S_C_STO_CA,
02299                    -1);
02300         hash = (_bfd_vms_length_hash_symbol
02301           (abfd, sym->name, EOBJ_S_C_SYMSIZ));
02302         _bfd_vms_output_counted (abfd, hash);
02303         _bfd_vms_output_flush (abfd);
02304             }
02305             break;
02306 
02307           default:
02308             (*_bfd_error_handler) (_("Unhandled relocation %s"),
02309                  (*rptr)->howto->name);
02310             break;
02311           }
02312 
02313         vaddr += len;
02314 
02315         if (len == sptr->size)
02316           {
02317             break;
02318           }
02319         else
02320           {
02321             sptr->contents += len;
02322             sptr->offset += len;
02323             sptr->size -= len;
02324             i--;
02325             rptr++;
02326           }
02327       }
02328           else      /* sptr starts after reloc */
02329       {
02330         i--;      /* check next reloc */
02331         rptr++;
02332       }
02333 
02334           if (i==0)     /* all reloc checked */
02335       {
02336         if (sptr->size > 0)
02337           {
02338             /* dump rest */
02339             sto_imm (abfd, sptr, vaddr, section->index);
02340             vaddr += sptr->size;
02341           }
02342         break;
02343       }
02344         } /* for (;;) */
02345     } /* if SEC_RELOC */
02346         else        /* no relocs, just dump */
02347     {
02348       sto_imm (abfd, sptr, vaddr, section->index);
02349       vaddr += sptr->size;
02350     }
02351 
02352         sptr = sptr->next;
02353 
02354       } /* while (sptr != 0) */
02355 
02356     end_etir_record (abfd);
02357 
02358   } /* has_contents */
02359 
02360       section = section->next;
02361     }
02362 
02363   _bfd_vms_output_alignment (abfd, 2);
02364   return 0;
02365 }
02366 
02367 /* Write traceback data for bfd abfd.  */
02368 
02369 int
02370 _bfd_vms_write_tbt (abfd, objtype)
02371      bfd *abfd ATTRIBUTE_UNUSED;
02372      int objtype ATTRIBUTE_UNUSED;
02373 {
02374 #if VMS_DEBUG
02375   _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype);
02376 #endif
02377 
02378   return 0;
02379 }
02380 
02381 /* Write debug info for bfd abfd.  */
02382 
02383 int
02384 _bfd_vms_write_dbg (abfd, objtype)
02385      bfd *abfd ATTRIBUTE_UNUSED;
02386      int objtype ATTRIBUTE_UNUSED;
02387 {
02388 #if VMS_DEBUG
02389   _bfd_vms_debug (2, "vms_write_dbg (%p, objtype)\n", abfd, objtype);
02390 #endif
02391 
02392   return 0;
02393 }