2009-02-23 Tristan Gingold <gingold@adacore.com>

	* vms.h: Update copyright year, fix comments, reorder declarations.
	(_bfd_save_vms_section): Remove the prototype.
	(EGPS_S_V_NO_SHIFT): New constant.
	(bfd_vms_set_section_flags): New prototype.
	(EGPS_S_B_ALIGN, EGPS_S_W_FLAGS, EGPS_S_L_ALLOC, EGPS_S_B_NAMLNG): New
	constants.
	(EGSY_S_W_FLAGS): Ditto.
	(EGSY_S_V_QUAD_VAL): Ditto.
	(ESDF_S_L_VALUE, ESDF_S_L_PSINDX, ESDF_S_B_NAMLNG): Ditto.
	(EGST_S_W_FLAGS, EGST_S_Q_LP_1, EGST_S_Q_LP_2, EGST_S_L_PSINDX,
	EGST_S_B_NAMLNG): Ditto.
	(ESRF_S_B_NAMLNG): Ditto.
	(ETIR_S_C_HEADER_SIZE): Ditto.
	(EGPS_S_V_ALLOC_64BIT): Ditto.
	(DST_S_C_EPILOG): Ditto.
	(DST_S_C_SRC_SETLNUM_L, DST_S_C_SRC_SETLNUM_W) : Ditto.
	(DST_S_C_SRC_INCRLNUM_B): Ditto.
	(DST_S_B_PCLINE_UNSBYTE, DST_S_W_PCLINE_UNSWORD): Ditto.
	(DST_S_L_PCLINE_UNSLONG): Ditto.
	(DST_S_B_MODBEG_NAME, DST_S_L_RTNBEG_ADDRESS) : Ditto
	(DST_S_B_RTNBEG_NAME, DST_S_L_RTNEND_SIZE): Ditto
	(DST_S_C_SOURCE_HEADER_SIZE): Ditto.
	(DST_S_B_SRC_DF_LENGTH, DST_S_W_SRC_DF_FILEID): Ditto.
	(DST_S_B_SRC_DF_FILENAME, DST_S_B_SRC_UNSBYTE): Ditto.
	(DST_S_B_SRC_UNSBYTE): Ditto.
	(DST_S_W_SRC_UNSWORD, DST_S_L_SRC_UNSLONG): Ditto.
	Add prototypes.
	(vms_section, vms_reloc): Remove types.
	(hdr_struc): Replaced by ...
	(hdr_struct): ... new type.
	(EMH_S_W_HDRTYP, EMH_S_B_STRLVL, EMH_S_L_ARCH1): New constants.
	(EMH_S_L_ARCH2, EMH_S_L_RECSIZ, EMH_S_B_NAMLNG): Ditto.
	(EMH_DATE_LENGTH): Ditto.
	(eom_struc): Replaced by ...
	(eom_struct): ... new type.
	(EEOM_S_L_TOTAL_LPS, EEOM_S_W_COMCOD, EEOM_S_B_TFRFLG): New constants.
	(EEOM_S_L_PSINDX, EEOM_S_L_TFRADR): Ditto.
	(EIHD_S_K_MAJORID, EIHD_S_K_MINORID, EIHD_S_K_EXE): Ditto.
	(EIHD_S_L_SIZE, EIHD_S_L_ISDOFF, EIHD_S_L_SYMDBGOFF): Ditto.
	(EIHD_S_Q_SYMVVA, EIHD_S_L_IMGTYPE): Ditto.
	(EISD_S_L_EISDSIZE, EISD_S_L_SECSIZE, EISD_S_Q_VIR_ADDR): Ditto.
	(EISD_S_L_FLAGS, EISD_S_L_VBN, EISD_S_R_CONTROL): Ditto.
	(EISD_S_L_IDENT, EISD_S_T_GBLNAM): Ditto.
	(EISD_S_M_GBL, EISD_S_M_CRF, EISD_S_M_DZRO, EISD_S_M_WRT): Ditto.
	(EISD_S_M_INITALCODE, EISD_S_M_BASED, EISD_S_M_FIXUPVEC): Ditto.
	(EISD_S_M_RESIDENT, EISD_S_M_VECTOR, EISD_S_M_PROTECT): Ditto.
	(EISD_S_M_LASTCLU, EISD_S_M_EXE, EISD_S_M_NONSHRADR): Ditto.
	(EISD_S_M_QUAD_LENGTH, EISD_S_M_ALLOC_64BIT): Ditto.
	(EIHS_S_L_DSTVBN, EIHS_S_L_DSTSIZE, EIHS_S_L_GSTVBN): Ditto.
	(EIHS_S_L_GSTSIZE, EIHS_S_L_DMTVBN, EIHS_S_L_DMTBYTES): Ditto.
	(DBG_S_L_DMT_MODBEG, DBG_S_L_DST_SIZE): Ditto.
	(DBG_S_W_DMT_PSECT_COUNT, DBG_S_C_DMT_HEADER_SIZE): Ditto.
	(DBG_S_L_DMT_PSECT_START, DBG_S_L_DMT_PSECT_LENGTH)
	(DBG_S_C_DMT_PSECT_SIZE): Ditto.
	(enum file_type_enum): New type.
	(struct location_struct): Removed.
	(struct fileinfo, struct srecinfo, struct lineinfo): New types.
	(struct funcinfo, struct module): Ditto.
	(struct vms_private_data_struct): Update fields.
	(struct vms_section_data_struct): New type.

	* vms.c: Update copyright year, fix comments,
	Fix includes for DECC, add prototypes.
	(vms_initialize): Use bfd_alloc instead of bfd_zalloc and remove
	some initializers.
	Use flavour to set is_vax, location_stack is removed.
	(struct pair): Declare.
	(fill_section_ptr): Initialize variables at declaration.
	Add guard to set SECTION_SYM flag, handlde und section.
	(vms_fixup_sections): Use struct pair for fill_section_ptr argument.
	(_bfd_vms_slurp_object_records): New function, replaces previous
	vms_object_p.
	(vms_slurp_module): New function.
	(vms_slurp_image): Ditto.
	(vms_object_p): Complete rewrite.
	(vms_mkobject): Use is_vax field to slect architecture.
	(free_reloc_stream): New function.
	(vms_convert_to_var): Ditto.
	(vms_convert_to_var_1): Ditto.
	(vms_convert_to_var_unix_filename): Ditto.
	(vms_close_and_cleanup): Call free_reloc_stream, convert file to
	VAR format on VMS.
	(vms_new_section_hook): Set alignment to 0, allocate private data.
	(vms_get_section_contents): Load content.
	(vms_get_symbol_info): Handle undefined section.
	(vms_find_nearest_line): Handle.
	(alloc_reloc_stream): New function.
	(vms_slurp_reloc_table): Ditto.
	(vms_get_reloc_upper_bound): Make it real.
	(vms_canonicalize_reloc): Do the real work.
	(alpha_howto_table): Add ALPHA_R_NOP, ALPHA_R_BSR, ALPHA_R_LDA,
	ALPHA_R_BOH.
	(vms_bfd_reloc_type_lookup): Handle NOP, BSR, LDA and BOH.
	(vms_set_arch_mach): Check arch.
	(vms_set_section_contents): Copy the content after allocation.
	(vms_alpha_vec): Update object flags.

	* vms-tir.c: Update copyright year, fix comments,
	add prototypes for new functions.
	(dst_define_location): New function.
	(dst_restore_location): New function.
	(dst_retrieve_location): New function.
	(dst_check_allocation): New function.
	(image_dump): Call dst_check_allocation.
	(image_write_b): Ditto.
	(image_write_w): Ditto.
	(image_write_l): Ditto.
	(image_write_q): Ditto.
	(cmd_name): Handle STA_LW, STA_QW, STO_OFF, STO_IMM, STO_IMMR, STO_LW,
	STO_QW, OPR_ADD, CTL_SETRB, STC_LP_PSB, CTL_DFLOC, CTL_STLOC,
	CTL_STKDL.
	Call error handler instead of abort if name is not known.
	(etir_sta): Add quarter_relocs argument and set it.
	Fix cast.
	(etir_sto): Ditto.
	(etir_opr): Ditto, return FALSE in case of error.
	(etir_ctl): Add quarter_relocs argument and set it, fix cast.
	Fix CTL_DFLOC, CTL_STLOC, CTL_STKDL.
	(etir_stc): Add quarter_relocs argument and set it, fix cast.
	Fix STC_LP, STC_LP_PSB, STC_GBL and STC_CGA.
	Handle STC_LP_PSB, STC_BSR_GBL, STC_LDA_GBL, STC_BOH_GBL.
	Move STC_NOP_PS, STC_BSR_PS, STC_LDA_PS, STC_BOH_PS, STC_NBH_PS.
	Return FALSE in case of error.
	(tir_sta): Change sign of psect.
	(tir_ctl): Ditto.
	(tir_cmd): Fix cast. Makes tir_table static const.
	(etir_cmd): Add quarter_relocs argument, makes etir_table const,
	add argument to explain.
	(analyze_etir): Initialize maxptr, add quarter_relocs
	declaration, move some declarations into inner scopes.
	Handle quarter_relocs and STO_IMM.
	(_bfd_vms_slurp_tir): Use constant instead of hard-coded values.
	(_bfd_vms_slurp_relocs): New function.
	(_bfd_vms_decode_relocs): New function.
	(sto_imm): Rewritten.
	(start_first_etbt_record): New function.
	(start_another_etbt_record): Ditto.
	(etir_output_check): Ditto.
	(defer_reloc_p): Ditto.
	(_bfd_vms_write_tir): Remove nextoffset, convert a while-loop to
	a for-loop.  Correctly deals with contents, deals with .vmsdebug,
	rewritte relocations handling.
	(_bfd_vms_write_tbt): Removed.
	(_bfd_vms_write_dbg): Ditto.

	* vms-misc.c: Update copyright year, Fix comments.
	(_bfd_vms_get_header_values): Use 'size' instead of 'length'.
	(maybe_adjust_record_pointer_for_object): New function.
	(_bfd_vms_get_first_record): New function, replaces ...
	(_bfd_vms_get_record): ..  removed.
	(_bfd_vms_get_object_record): New function.
	(_bfd_vms_get_object_record): New function.
	(vms_get_remaining_object_record): New function, replaces ...
	(_bfd_vms_get_next_record): ... removed.
	(add_new_contents): Removed.
	(_bfd_save_vms_section): Removed.
	(_bfd_get_vms_section): Removed.
	(_bfd_vms_output_flush): Write in VAR format.
	(new_symbol): Don't make UND section.

	* vms-hdr.c: Update copyright year, update list of record handled.
	(_bfd_vms_slurp_hdr): rec_length renamed to rec_size.
	(_bfd_vms_write_hdr): Strip vms and unix patches,
	add comments, truncate module name at 31 characters,
	use constants instead of hard-coded value,
	write BFD version instead of a fixed string.
	(_bfd_vms_slurp_ihd): New function.
	(_bfd_vms_slurp_isd): Ditto.
	(_bfd_vms_slurp_ihs): Ditto.
	(new_module): Ditto.
	(parse_module): Ditto
	(build_module_list): Ditto.
	(module_find_nearest_line): Ditto.
	(_bfd_vms_find_nearest_dst_line): Ditto.
	(vms_slurp_debug): Ditto.
	(_bfd_vms_slurp_dbg): Ditto.
	(_bfd_vms_slurp_tbt): Ditto.
	(_bfd_vms_write_dbg): Ditto.
	(_bfd_vms_write_tbt): Ditto.

	* vms-gsd.c: Update copyright year, update list of records handled.
	(EVAX_LITERALS_NAME): New macro.
	(evax_section_flags): Add an entry for EVAX_LITERALS_NAME.
	(gpsflagdesc, gsyflagdesc): Moved out of _bfd_vms_slurp_gsd.
	(register_universal_symbol): New function and prototype.
	(_bfd_vms_slurp_gsd): Fix indentations and casts,
	improve debug messages,
	use constants instead of hard-coded value,
	fix missing endianness conversion,
	handle global symbol (SYMG).
	(bfd_vms_set_section_flags): New function.
	(_bfd_vms_write_gsd): Don't write .vmsdebug section,
	handle section literals,
	fix indentation,
	handle section bfd and vms flags,
	don't output LIB$INITIALIZE symbol,
	fix handling of weak symbols,
	fix evax vs vax procedure descriptor,
	handle absolute symbols.

	* reloc.c (BFD_RELOC_ALPHA_NOP, BFD_RELOC_ALPHA_BSR,
	BFD_RELOC_ALPHA_LDA, BFD_RELOC_ALPHA_BOH): New relocations.

	* makefile.vms (DEFS): Fix flags for VMS.

	* bfdio.c (real_fopen): Handle multiple VMS fopen attributes.

	* bfd-in2.h: Regenerated.
	* libbfd.h: Regenerated.

12 files changed, 4026 insertions, 1236 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 32ae0d89..17a23d7 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,215 @@
+2009-02-23  Tristan Gingold  <gingold@adacore.com>
+
+	* vms.h: Update copyright year, fix comments, reorder declarations.
+	(_bfd_save_vms_section): Remove the prototype.
+	(EGPS_S_V_NO_SHIFT): New constant.
+	(bfd_vms_set_section_flags): New prototype.
+	(EGPS_S_B_ALIGN, EGPS_S_W_FLAGS, EGPS_S_L_ALLOC, EGPS_S_B_NAMLNG): New
+	constants.
+	(EGSY_S_W_FLAGS): Ditto.
+	(EGSY_S_V_QUAD_VAL): Ditto.
+	(ESDF_S_L_VALUE, ESDF_S_L_PSINDX, ESDF_S_B_NAMLNG): Ditto.
+	(EGST_S_W_FLAGS, EGST_S_Q_LP_1, EGST_S_Q_LP_2, EGST_S_L_PSINDX,
+	EGST_S_B_NAMLNG): Ditto.
+	(ESRF_S_B_NAMLNG): Ditto.
+	(ETIR_S_C_HEADER_SIZE): Ditto.
+	(EGPS_S_V_ALLOC_64BIT): Ditto.
+	(DST_S_C_EPILOG): Ditto.
+	(DST_S_C_SRC_SETLNUM_L, DST_S_C_SRC_SETLNUM_W) : Ditto.
+	(DST_S_C_SRC_INCRLNUM_B): Ditto.
+	(DST_S_B_PCLINE_UNSBYTE, DST_S_W_PCLINE_UNSWORD): Ditto.
+	(DST_S_L_PCLINE_UNSLONG): Ditto.
+	(DST_S_B_MODBEG_NAME, DST_S_L_RTNBEG_ADDRESS) : Ditto
+	(DST_S_B_RTNBEG_NAME, DST_S_L_RTNEND_SIZE): Ditto
+	(DST_S_C_SOURCE_HEADER_SIZE): Ditto.
+	(DST_S_B_SRC_DF_LENGTH, DST_S_W_SRC_DF_FILEID): Ditto.
+	(DST_S_B_SRC_DF_FILENAME, DST_S_B_SRC_UNSBYTE): Ditto.
+	(DST_S_B_SRC_UNSBYTE): Ditto.
+	(DST_S_W_SRC_UNSWORD, DST_S_L_SRC_UNSLONG): Ditto.
+	Add prototypes.
+	(vms_section, vms_reloc): Remove types.
+	(hdr_struc): Replaced by ...
+	(hdr_struct): ... new type.
+	(EMH_S_W_HDRTYP, EMH_S_B_STRLVL, EMH_S_L_ARCH1): New constants.
+	(EMH_S_L_ARCH2, EMH_S_L_RECSIZ, EMH_S_B_NAMLNG): Ditto.
+	(EMH_DATE_LENGTH): Ditto.
+	(eom_struc): Replaced by ...
+	(eom_struct): ... new type.
+	(EEOM_S_L_TOTAL_LPS, EEOM_S_W_COMCOD, EEOM_S_B_TFRFLG): New constants.
+	(EEOM_S_L_PSINDX, EEOM_S_L_TFRADR): Ditto.
+	(EIHD_S_K_MAJORID, EIHD_S_K_MINORID, EIHD_S_K_EXE): Ditto.
+	(EIHD_S_L_SIZE, EIHD_S_L_ISDOFF, EIHD_S_L_SYMDBGOFF): Ditto.
+	(EIHD_S_Q_SYMVVA, EIHD_S_L_IMGTYPE): Ditto.
+	(EISD_S_L_EISDSIZE, EISD_S_L_SECSIZE, EISD_S_Q_VIR_ADDR): Ditto.
+	(EISD_S_L_FLAGS, EISD_S_L_VBN, EISD_S_R_CONTROL): Ditto.
+	(EISD_S_L_IDENT, EISD_S_T_GBLNAM): Ditto.
+	(EISD_S_M_GBL, EISD_S_M_CRF, EISD_S_M_DZRO, EISD_S_M_WRT): Ditto.
+	(EISD_S_M_INITALCODE, EISD_S_M_BASED, EISD_S_M_FIXUPVEC): Ditto.
+	(EISD_S_M_RESIDENT, EISD_S_M_VECTOR, EISD_S_M_PROTECT): Ditto.
+	(EISD_S_M_LASTCLU, EISD_S_M_EXE, EISD_S_M_NONSHRADR): Ditto.
+	(EISD_S_M_QUAD_LENGTH, EISD_S_M_ALLOC_64BIT): Ditto.
+	(EIHS_S_L_DSTVBN, EIHS_S_L_DSTSIZE, EIHS_S_L_GSTVBN): Ditto.
+	(EIHS_S_L_GSTSIZE, EIHS_S_L_DMTVBN, EIHS_S_L_DMTBYTES): Ditto.
+	(DBG_S_L_DMT_MODBEG, DBG_S_L_DST_SIZE): Ditto.
+	(DBG_S_W_DMT_PSECT_COUNT, DBG_S_C_DMT_HEADER_SIZE): Ditto.
+	(DBG_S_L_DMT_PSECT_START, DBG_S_L_DMT_PSECT_LENGTH)
+	(DBG_S_C_DMT_PSECT_SIZE): Ditto.
+	(enum file_type_enum): New type.
+	(struct location_struct): Removed.
+	(struct fileinfo, struct srecinfo, struct lineinfo): New types.
+	(struct funcinfo, struct module): Ditto.
+	(struct vms_private_data_struct): Update fields.
+	(struct vms_section_data_struct): New type.
+
+	* vms.c: Update copyright year, fix comments,
+	Fix includes for DECC, add prototypes.
+	(vms_initialize): Use bfd_alloc instead of bfd_zalloc and remove
+	some initializers.
+	Use flavour to set is_vax, location_stack is removed.
+	(struct pair): Declare.
+	(fill_section_ptr): Initialize variables at declaration.
+	Add guard to set SECTION_SYM flag, handlde und section.
+	(vms_fixup_sections): Use struct pair for fill_section_ptr argument.
+	(_bfd_vms_slurp_object_records): New function, replaces previous
+	vms_object_p.
+	(vms_slurp_module): New function.
+	(vms_slurp_image): Ditto.
+	(vms_object_p): Complete rewrite.
+	(vms_mkobject): Use is_vax field to slect architecture.
+	(free_reloc_stream): New function.
+	(vms_convert_to_var): Ditto.
+	(vms_convert_to_var_1): Ditto.
+	(vms_convert_to_var_unix_filename): Ditto.
+	(vms_close_and_cleanup): Call free_reloc_stream, convert file to
+	VAR format on VMS.
+	(vms_new_section_hook): Set alignment to 0, allocate private data.
+	(vms_get_section_contents): Load content.
+	(vms_get_symbol_info): Handle undefined section.
+	(vms_find_nearest_line): Handle.
+	(alloc_reloc_stream): New function.
+	(vms_slurp_reloc_table): Ditto.
+	(vms_get_reloc_upper_bound): Make it real.
+	(vms_canonicalize_reloc): Do the real work.
+	(alpha_howto_table): Add ALPHA_R_NOP, ALPHA_R_BSR, ALPHA_R_LDA,
+	ALPHA_R_BOH.
+	(vms_bfd_reloc_type_lookup): Handle NOP, BSR, LDA and BOH.
+	(vms_set_arch_mach): Check arch.
+	(vms_set_section_contents): Copy the content after allocation.
+	(vms_alpha_vec): Update object flags.
+
+	* vms-tir.c: Update copyright year, fix comments,
+	add prototypes for new functions.
+	(dst_define_location): New function.
+	(dst_restore_location): New function.
+	(dst_retrieve_location): New function.
+	(dst_check_allocation): New function.
+	(image_dump): Call dst_check_allocation.
+	(image_write_b): Ditto.
+	(image_write_w): Ditto.
+	(image_write_l): Ditto.
+	(image_write_q): Ditto.
+	(cmd_name): Handle STA_LW, STA_QW, STO_OFF, STO_IMM, STO_IMMR, STO_LW,
+	STO_QW, OPR_ADD, CTL_SETRB, STC_LP_PSB, CTL_DFLOC, CTL_STLOC,
+	CTL_STKDL.
+	Call error handler instead of abort if name is not known.
+	(etir_sta): Add quarter_relocs argument and set it.
+	Fix cast.
+	(etir_sto): Ditto.
+	(etir_opr): Ditto, return FALSE in case of error.
+	(etir_ctl): Add quarter_relocs argument and set it, fix cast.
+	Fix CTL_DFLOC, CTL_STLOC, CTL_STKDL.
+	(etir_stc): Add quarter_relocs argument and set it, fix cast.
+	Fix STC_LP, STC_LP_PSB, STC_GBL and STC_CGA.
+	Handle STC_LP_PSB, STC_BSR_GBL, STC_LDA_GBL, STC_BOH_GBL.
+	Move STC_NOP_PS, STC_BSR_PS, STC_LDA_PS, STC_BOH_PS, STC_NBH_PS.
+	Return FALSE in case of error.
+	(tir_sta): Change sign of psect.
+	(tir_ctl): Ditto.
+	(tir_cmd): Fix cast. Makes tir_table static const.
+	(etir_cmd): Add quarter_relocs argument, makes etir_table const,
+	add argument to explain.
+	(analyze_etir): Initialize maxptr, add quarter_relocs
+	declaration, move some declarations into inner scopes.
+	Handle quarter_relocs and STO_IMM.
+	(_bfd_vms_slurp_tir): Use constant instead of hard-coded values.
+	(_bfd_vms_slurp_relocs): New function.
+	(_bfd_vms_decode_relocs): New function.
+	(sto_imm): Rewritten.
+	(start_first_etbt_record): New function.
+	(start_another_etbt_record): Ditto.
+	(etir_output_check): Ditto.
+	(defer_reloc_p): Ditto.
+	(_bfd_vms_write_tir): Remove nextoffset, convert a while-loop to
+	a for-loop.  Correctly deals with contents, deals with .vmsdebug,
+	rewritte relocations handling.
+	(_bfd_vms_write_tbt): Removed.
+	(_bfd_vms_write_dbg): Ditto.
+
+	* vms-misc.c: Update copyright year, Fix comments.
+	(_bfd_vms_get_header_values): Use 'size' instead of 'length'.
+	(maybe_adjust_record_pointer_for_object): New function.
+	(_bfd_vms_get_first_record): New function, replaces ...
+	(_bfd_vms_get_record): ..  removed.
+	(_bfd_vms_get_object_record): New function.
+	(_bfd_vms_get_object_record): New function.
+	(vms_get_remaining_object_record): New function, replaces ...
+	(_bfd_vms_get_next_record): ... removed.
+	(add_new_contents): Removed.
+	(_bfd_save_vms_section): Removed.
+	(_bfd_get_vms_section): Removed.
+	(_bfd_vms_output_flush): Write in VAR format.
+	(new_symbol): Don't make UND section.
+
+	* vms-hdr.c: Update copyright year, update list of record handled.
+	(_bfd_vms_slurp_hdr): rec_length renamed to rec_size.
+	(_bfd_vms_write_hdr): Strip vms and unix patches,
+	add comments, truncate module name at 31 characters,
+	use constants instead of hard-coded value,
+	write BFD version instead of a fixed string.
+	(_bfd_vms_slurp_ihd): New function.
+	(_bfd_vms_slurp_isd): Ditto.
+	(_bfd_vms_slurp_ihs): Ditto.
+	(new_module): Ditto.
+	(parse_module): Ditto
+	(build_module_list): Ditto.
+	(module_find_nearest_line): Ditto.
+	(_bfd_vms_find_nearest_dst_line): Ditto.
+	(vms_slurp_debug): Ditto.
+	(_bfd_vms_slurp_dbg): Ditto.
+	(_bfd_vms_slurp_tbt): Ditto.
+	(_bfd_vms_write_dbg): Ditto.
+	(_bfd_vms_write_tbt): Ditto.
+
+	* vms-gsd.c: Update copyright year, update list of records handled.
+	(EVAX_LITERALS_NAME): New macro.
+	(evax_section_flags): Add an entry for EVAX_LITERALS_NAME.
+	(gpsflagdesc, gsyflagdesc): Moved out of _bfd_vms_slurp_gsd.
+	(register_universal_symbol): New function and prototype.
+	(_bfd_vms_slurp_gsd): Fix indentations and casts,
+	improve debug messages,
+	use constants instead of hard-coded value,
+	fix missing endianness conversion,
+	handle global symbol (SYMG).
+	(bfd_vms_set_section_flags): New function.
+	(_bfd_vms_write_gsd): Don't write .vmsdebug section,
+	handle section literals,
+	fix indentation,
+	handle section bfd and vms flags,
+	don't output LIB$INITIALIZE symbol,
+	fix handling of weak symbols,
+	fix evax vs vax procedure descriptor,
+	handle absolute symbols.
+
+	* reloc.c (BFD_RELOC_ALPHA_NOP, BFD_RELOC_ALPHA_BSR,
+	BFD_RELOC_ALPHA_LDA, BFD_RELOC_ALPHA_BOH): New relocations.
+
+	* makefile.vms (DEFS): Fix flags for VMS.
+
+	* bfdio.c (real_fopen): Handle multiple VMS fopen attributes.
+
+	* bfd-in2.h: Regenerated.
+	* libbfd.h: Regenerated.
+
 2009-02-20  Cary Coutant  <ccoutant@google.com>
 
 	* vmsutil.c (vms_file_stats_name): Fix incorrect use of st_mtime
diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h
index 994759d..7870962 100644
--- a/bfd/bfd-in2.h
+++ b/bfd/bfd-in2.h
@@ -2586,6 +2586,22 @@ share a common GP, and the target address is adjusted for
 STO_ALPHA_STD_GPLOAD.  */
   BFD_RELOC_ALPHA_BRSGP,
 
+/* The NOP relocation outputs a NOP if the longword displacement
+between two procedure entry points is < 2^21.  */
+  BFD_RELOC_ALPHA_NOP,
+
+/* The BSR relocation outputs a BSR if the longword displacement
+between two procedure entry points is < 2^21.  */
+  BFD_RELOC_ALPHA_BSR,
+
+/* The LDA relocation outputs a LDA if the longword displacement
+between two procedure entry points is < 2^16.  */
+  BFD_RELOC_ALPHA_LDA,
+
+/* The BOH relocation outputs a BSR if the longword displacement
+between two procedure entry points is < 2^21, or else a hint.  */
+  BFD_RELOC_ALPHA_BOH,
+
 /* Alpha thread-local storage relocations.  */
   BFD_RELOC_ALPHA_TLSGD,
   BFD_RELOC_ALPHA_TLSLDM,
diff --git a/bfd/bfdio.c b/bfd/bfdio.c
index 7cba51f..d3a295c 100644
--- a/bfd/bfdio.c
+++ b/bfd/bfdio.c
@@ -102,13 +102,21 @@ real_fopen (const char *filename, const char *modes)
     }
   else
     {
-      /* Attribute found - rebuild modes.  */
-      size_t modes_len = vms_attr - modes;
-
-      BFD_ASSERT (modes_len < sizeof (vms_modes));
-      memcpy (vms_modes, modes, modes_len);
-      vms_modes[modes_len] = 0;
-      return close_on_exec (fopen (filename, vms_modes, vms_attr + 1));
+      /* Attributes found.  Split.  */
+      size_t modes_len = strlen (modes) + 1;
+      char attrs[modes_len + 1];
+      char *at[3];
+      int i;
+
+      memcpy (attrs, modes, modes_len);
+      at[0] = attrs;
+      for (i = 0; i < 2; i++)
+	{
+	  at[i + 1] = strchr (at[i], ',');
+	  BFD_ASSERT (at[i + 1] != NULL);
+	  *(at[i + 1]++) = 0; /* Replace ',' with a nul, and skip it.  */
+	}
+      return close_on_exec (fopen (filename, at[0], at[1], at[2]));
     }
 #else /* !VMS */
 #if defined (HAVE_FOPEN64)
diff --git a/bfd/libbfd.h b/bfd/libbfd.h
index 26238b5..2ba7fc8 100644
--- a/bfd/libbfd.h
+++ b/bfd/libbfd.h
@@ -957,6 +957,10 @@ static const char *const bfd_reloc_code_real_names[] = { "@@uninitialized@@",
   "BFD_RELOC_ALPHA_GPREL_HI16",
   "BFD_RELOC_ALPHA_GPREL_LO16",
   "BFD_RELOC_ALPHA_BRSGP",
+  "BFD_RELOC_ALPHA_NOP",
+  "BFD_RELOC_ALPHA_BSR",
+  "BFD_RELOC_ALPHA_LDA",
+  "BFD_RELOC_ALPHA_BOH",
   "BFD_RELOC_ALPHA_TLSGD",
   "BFD_RELOC_ALPHA_TLSLDM",
   "BFD_RELOC_ALPHA_DTPMOD64",
diff --git a/bfd/makefile.vms b/bfd/makefile.vms
index 963441a..2e2d2a1 100644
--- a/bfd/makefile.vms
+++ b/bfd/makefile.vms
@@ -36,13 +36,15 @@ endif
 CFLAGS=/include=([],[-.include])$(DEFS)
 else
 ifeq ($(ARCH),ALPHA)
-DEFS=/define=(SELECT_VECS="&vms_alpha_vec",SELECT_ARCHITECTURES="&bfd_alpha_arch",\
-"HAVE_vms_alpha_vec=1","unlink=remove","DEBUGDIR=NULL")
+DEFS=/define=(SELECT_VECS="&vms_alpha_vec",\
+  SELECT_ARCHITECTURES="&bfd_alpha_arch",\
+  "HAVE_vms_alpha_vec=1","unlink=remove","DEBUGDIR=NULL")
 else
 DEFS=/define=(SELECT_VECS="&vms_vax_vec",SELECT_ARCHITECTURES="&bfd_vax_arch",\
-"HAVE_vms_vax_vec=1","unlink=remove","const=")
+  "HAVE_vms_vax_vec=1","unlink=remove")
 endif
-CFLAGS=/noopt/debug/show=incl/name=(as_is,shortened)/include=([],[-.include])$(DEFS)/warnings=disable=(missingreturn,longextern)
+OPT=/noopt/debug
+CFLAGS=/name=(as_is,shortened)/include=([],[-.include])$(DEFS)$(OPT)
 endif
 
 
diff --git a/bfd/reloc.c b/bfd/reloc.c
index 0c0fb1d3..781147e 100644
--- a/bfd/reloc.c
+++ b/bfd/reloc.c
@@ -2110,6 +2110,30 @@ ENUMDOC
   STO_ALPHA_STD_GPLOAD.
 
 ENUM
+  BFD_RELOC_ALPHA_NOP
+ENUMDOC
+  The NOP relocation outputs a NOP if the longword displacement
+     between two procedure entry points is < 2^21.
+
+ENUM
+  BFD_RELOC_ALPHA_BSR
+ENUMDOC
+  The BSR relocation outputs a BSR if the longword displacement
+     between two procedure entry points is < 2^21.
+
+ENUM
+  BFD_RELOC_ALPHA_LDA
+ENUMDOC
+  The LDA relocation outputs a LDA if the longword displacement
+     between two procedure entry points is < 2^16.
+
+ENUM
+  BFD_RELOC_ALPHA_BOH
+ENUMDOC
+  The BOH relocation outputs a BSR if the longword displacement
+     between two procedure entry points is < 2^21, or else a hint.
+
+ENUM
   BFD_RELOC_ALPHA_TLSGD
 ENUMX
   BFD_RELOC_ALPHA_TLSLDM
diff --git a/bfd/vms-gsd.c b/bfd/vms-gsd.c
index 4bdc27c..e641d0d 100644
--- a/bfd/vms-gsd.c
+++ b/bfd/vms-gsd.c
@@ -1,9 +1,12 @@
 /* vms-gsd.c -- BFD back-end for VAX (openVMS/VAX) and
    EVAX (openVMS/Alpha) files.
    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-   2007 Free Software Foundation, Inc.
+   2007, 2009 Free Software Foundation, Inc.
 
-   go and read the openVMS linker manual (esp. appendix B)
+   GSD record handling functions
+   EGSD record handling functions
+
+   Go and read the openVMS linker manual (esp. appendix B)
    if you don't know what's going on here :-)
 
    Written by Klaus K"ampf (kkaempf@rmi.de)
@@ -46,6 +49,7 @@
 #define EVAX_READONLYADDR_NAME	"$READONLY_ADDR$"
 #define EVAX_READONLY_NAME	"$READONLY$"
 #define EVAX_LITERAL_NAME	"$LITERAL$"
+#define EVAX_LITERALS_NAME	"$LITERALS"
 #define EVAX_COMMON_NAME	"$COMMON$"
 #define EVAX_LOCAL_NAME		"$LOCAL$"
 
@@ -133,6 +137,11 @@ static struct sec_flags_struct evax_section_flags[] =
       (SEC_DATA),
       (EGPS_S_V_REL | EGPS_S_V_RD | EGPS_S_V_WRT),
       (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
+    { EVAX_LITERALS_NAME,
+      (EGPS_S_V_PIC | EGPS_S_V_OVR),
+      (SEC_DATA | SEC_READONLY),
+      (EGPS_S_V_PIC | EGPS_S_V_OVR),
+      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
     { NULL,
       (EGPS_S_V_REL | EGPS_S_V_RD | EGPS_S_V_WRT),
       (SEC_DATA),
@@ -197,6 +206,37 @@ vms_esecflag_by_name (struct sec_flags_struct *section_flags,
 
 struct flagdescstruct { char *name; flagword value; };
 
+static const struct flagdescstruct gpsflagdesc[] =
+{
+  { "PIC", GPS_S_M_PIC },
+  { "LIB", GPS_S_M_LIB },
+  { "OVR", GPS_S_M_OVR },
+  { "REL", GPS_S_M_REL },
+  { "GBL", GPS_S_M_GBL },
+  { "SHR", GPS_S_M_SHR },
+  { "EXE", GPS_S_M_EXE },
+  { "RD",  GPS_S_M_RD },
+  { "WRT", GPS_S_M_WRT },
+  { "VEC", GPS_S_M_VEC },
+  { "NOMOD", EGPS_S_V_NOMOD },
+  { "COM", EGPS_S_V_COM },
+  { NULL, 0 }
+};
+
+static const struct flagdescstruct gsyflagdesc[] =
+{
+  { "WEAK", GSY_S_M_WEAK },
+  { "DEF",  GSY_S_M_DEF },
+  { "UNI",  GSY_S_M_UNI },
+  { "REL",  GSY_S_M_REL },
+  { "COMM", EGSY_S_V_COMM },
+  { "VECEP", EGSY_S_V_VECEP },
+  { "NORM", EGCY_S_V_NORM },
+  { NULL, 0 }
+};
+
+static char *flag2str (struct flagdescstruct *, flagword);
+
 /* Convert flag to printable string.  */
 
 static char *
@@ -224,43 +264,15 @@ flag2str (struct flagdescstruct * flagdesc, flagword flags)
 
 /* Input routines.  */
 
+static int register_universal_symbol (bfd *abfd, asymbol *symbol,
+				      int vms_flags);
+
 /* Process GSD/EGSD record
    return 0 on success, -1 on error.  */
 
 int
 _bfd_vms_slurp_gsd (bfd * abfd, int objtype)
 {
-#if VMS_DEBUG
-  static struct flagdescstruct gpsflagdesc[] =
-    {
-      { "PIC", 0x0001 },
-      { "LIB", 0x0002 },
-      { "OVR", 0x0004 },
-      { "REL", 0x0008 },
-      { "GBL", 0x0010 },
-      { "SHR", 0x0020 },
-      { "EXE", 0x0040 },
-      { "RD",  0x0080 },
-      { "WRT", 0x0100 },
-      { "VEC", 0x0200 },
-      { "NOMOD", 0x0400 },
-      { "COM", 0x0800 },
-      { NULL, 0 }
-    };
-
-  static struct flagdescstruct gsyflagdesc[] =
-    {
-      { "WEAK", 0x0001 },
-      { "DEF",  0x0002 },
-      { "UNI",  0x0004 },
-      { "REL",  0x0008 },
-      { "COMM", 0x0010 },
-      { "VECEP", 0x0020 },
-      { "NORM", 0x0040 },
-      { NULL, 0 }
-    };
-#endif
-
   int gsd_type, gsd_size;
   asection *section;
   unsigned char *vms_rec;
@@ -300,7 +312,7 @@ _bfd_vms_slurp_gsd (bfd * abfd, int objtype)
       vms_rec = PRIV (vms_rec);
 
       if (objtype == OBJ_S_C_GSD)
-	gsd_type = *vms_rec;
+	gsd_type = vms_rec[0];
       else
 	{
 	  _bfd_vms_get_header_values (abfd, vms_rec, &gsd_type, &gsd_size);
@@ -322,7 +334,7 @@ _bfd_vms_slurp_gsd (bfd * abfd, int objtype)
 	    vms_debug (4, "GSD_S_C_PSC\n");
 #endif
 	    /* If this section isn't a bfd section.  */
-	    if (PRIV (is_vax) && (psect_idx < (abfd->section_count-1)))
+	    if (PRIV (is_vax) && (psect_idx < (abfd->section_count - 1)))
 	      {
 		/* Check for temporary section from TIR record.  */
 		if (psect_idx < PRIV (section_count))
@@ -362,7 +374,6 @@ _bfd_vms_slurp_gsd (bfd * abfd, int objtype)
 	    base_addr += section->size;
 
 	    /* Global section is common symbol.  */
-
 	    if (old_flags & GPS_S_M_GBL)
 	      {
 		entry = _bfd_vms_enter_symbol (abfd, name);
@@ -496,21 +507,20 @@ _bfd_vms_slurp_gsd (bfd * abfd, int objtype)
 		else
 		  psect = vms_rec[value_offset-1];
 
-		symbol->section = (asection *) (size_t) psect;
+		symbol->section = (asection *)(unsigned long)psect;
 #if VMS_DEBUG
-		vms_debug (4, "gsd sym def #%d (%s, %d [%p], %04x=%s)\n", abfd->symcount,
-			   symbol->name, (int)symbol->section, symbol->section, old_flags, flag2str (gsyflagdesc, old_flags));
+		vms_debug (4, "gsd sym def #%d (%s, %ld, %04x=%s)\n", abfd->symcount,
+			  symbol->name, (long)symbol->section, old_flags, flag2str(gsyflagdesc, old_flags));
 #endif
 	      }
 	    else
 	      {
 		/* Symbol reference.  */
-		symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME);
 #if VMS_DEBUG
-		vms_debug (4, "gsd sym ref #%d (%s, %s [%p], %04x=%s)\n",
-			   abfd->symcount, symbol->name, symbol->section->name,
-			   symbol->section, old_flags, flag2str (gsyflagdesc, old_flags));
+		vms_debug (4, "gsd sym ref #%d (%s, %04x=%s)\n", abfd->symcount,
+			   symbol->name, old_flags, flag2str (gsyflagdesc, old_flags));
 #endif
+		symbol->section = (asection *)(unsigned long)-1;
 	      }
 
 	    gsd_size = vms_rec[name_offset] + name_offset + 1;
@@ -574,19 +584,19 @@ _bfd_vms_slurp_gsd (bfd * abfd, int objtype)
 	case EGSD_S_C_PSC + EVAX_OFFSET:
 	  {
 	    /* Program section definition.  */
-	    name = _bfd_vms_save_counted_string (vms_rec + 12);
+	    name = _bfd_vms_save_counted_string (vms_rec + EGPS_S_B_NAMLNG);
 	    section = bfd_make_section (abfd, name);
 	    if (!section)
 	      return -1;
-	    old_flags = bfd_getl16 (vms_rec + 6);
-	    section->size = bfd_getl32 (vms_rec + 8);	/* Allocation.  */
+	    old_flags = bfd_getl16 (vms_rec + EGPS_S_W_FLAGS);
+	    section->size = bfd_getl32 (vms_rec + EGPS_S_L_ALLOC);
 	    new_flags = vms_secflag_by_name (abfd, evax_section_flags, name,
 					     section->size > 0);
 	    if (old_flags & EGPS_S_V_REL)
 	      new_flags |= SEC_RELOC;
 	    if (!bfd_set_section_flags (abfd, section, new_flags))
 	      return -1;
-	    section->alignment_power = vms_rec[4];
+	    section->alignment_power = vms_rec[EGPS_S_B_ALIGN];
 	    align_addr = (1 << section->alignment_power);
 	    if ((base_addr % align_addr) != 0)
 	      base_addr += (align_addr - (base_addr % align_addr));
@@ -595,9 +605,10 @@ _bfd_vms_slurp_gsd (bfd * abfd, int objtype)
 	    section->contents = bfd_zmalloc (section->size);
 	    if (section->contents == NULL)
 	      return -1;
+	    section->filepos = (unsigned int)-1;
 #if VMS_DEBUG
-	    vms_debug (4, "egsd psc %d (%s, flags %04x=%s) ",
-		       section->index, name, old_flags, flag2str (gpsflagdesc, old_flags));
+	    vms_debug (4, "EGSD P-section %d (%s, flags %04x=%s) ",
+		       section->index, name, old_flags, flag2str(gpsflagdesc, old_flags));
 	    vms_debug (4, "%d bytes at 0x%08lx (mem %p)\n",
 		       section->size, section->vma, section->contents);
 #endif
@@ -606,50 +617,52 @@ _bfd_vms_slurp_gsd (bfd * abfd, int objtype)
 
 	case EGSD_S_C_SYM + EVAX_OFFSET:
 	  {
-	    /* Symbol specification (definition or reference).  */
+	    /* Global symbol specification (definition or reference).  */
 	    symbol = bfd_make_empty_symbol (abfd);
 	    if (symbol == 0)
 	      return -1;
 
-	    old_flags = bfd_getl16 (vms_rec + 6);
+	    old_flags = bfd_getl16 (vms_rec + EGSY_S_W_FLAGS);
 	    new_flags = BSF_NO_FLAGS;
 
 	    if (old_flags & EGSY_S_V_WEAK)
 	      new_flags |= BSF_WEAK;
 
-	    if (vms_rec[6] & EGSY_S_V_DEF)
+	    if (old_flags & EGSY_S_V_DEF)
 	      {
 		/* Symbol definition.  */
-		symbol->name = _bfd_vms_save_counted_string (vms_rec + 32);
 		if (old_flags & EGSY_S_V_NORM)
-		  /* Proc def.  */
 		  new_flags |= BSF_FUNCTION;
-
-		symbol->value = bfd_getl64 (vms_rec + 8);
-		symbol->section = (asection *) ((unsigned long) bfd_getl32 (vms_rec + 28));
+		symbol->name =
+		  _bfd_vms_save_counted_string (vms_rec + ESDF_S_B_NAMLNG);
+		symbol->value = bfd_getl64 (vms_rec + ESDF_S_L_VALUE);
+		symbol->section =
+		  (asection *)(unsigned long) bfd_getl32 (vms_rec + ESDF_S_L_PSINDX);
 #if VMS_DEBUG
-		vms_debug (4, "egsd sym def #%d (%s, %d, %04x=%s)\n", abfd->symcount,
-			   symbol->name, (int) symbol->section, old_flags,
-			   flag2str (gsyflagdesc, old_flags));
+		vms_debug (4, "EGSD sym def #%d (%s, %ld, %04x=%s)\n",
+			   abfd->symcount, symbol->name, (long)symbol->section,
+			   old_flags, flag2str (gsyflagdesc, old_flags));
 #endif
 	      }
 	    else
 	      {
 		/* Symbol reference.  */
-		symbol->name = _bfd_vms_save_counted_string (vms_rec + 8);
+		symbol->name =
+		  _bfd_vms_save_counted_string (vms_rec + ESRF_S_B_NAMLNG);
 #if VMS_DEBUG
-		vms_debug (4, "egsd sym ref #%d (%s, %04x=%s)\n", abfd->symcount,
-			  symbol->name, old_flags, flag2str (gsyflagdesc, old_flags));
+		vms_debug (4, "EGSD sym ref #%d (%s, %04x=%s)\n",
+			   abfd->symcount, symbol->name, old_flags,
+			   flag2str (gsyflagdesc, old_flags));
 #endif
-		symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME);
+		symbol->section = (asection *)(unsigned long)-1;
 	      }
 
 	    symbol->flags = new_flags;
 
-	    /* Save symbol in vms_symbol_table.  */
-	    entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
-							  symbol->name,
-							  TRUE, FALSE);
+	    /* Register symbol in VMS symbol table.  */
+	    entry = (vms_symbol_entry *) bfd_hash_lookup
+	      (PRIV (vms_symbol_table), symbol->name, TRUE, FALSE);
+
 	    if (entry == NULL)
 	      {
 		bfd_set_error (bfd_error_no_memory);
@@ -672,11 +685,73 @@ _bfd_vms_slurp_gsd (bfd * abfd, int objtype)
 	  }
 	  break;
 
-	case EGSD_S_C_IDC + EVAX_OFFSET:
+	case EGSD_S_C_SYMG + EVAX_OFFSET:
+	  {
+	    /* Universal symbol specification (definition).  */
+	    symbol = bfd_make_empty_symbol (abfd);
+	    if (symbol == 0)
+	      return -1;
+
+	    old_flags = bfd_getl16 (vms_rec + EGST_S_W_FLAGS);
+	    new_flags = BSF_NO_FLAGS;
+
+	    if (old_flags & EGSY_S_V_WEAK)
+	      new_flags |= BSF_WEAK;
+
+	    if (old_flags & EGSY_S_V_DEF) /* symbol definition */
+	      {
+		if (old_flags & EGSY_S_V_NORM)
+		  new_flags |= BSF_FUNCTION;
+
+		symbol->name =
+		  _bfd_vms_save_counted_string (vms_rec + EGST_S_B_NAMLNG);
+
+		/* For BSF_FUNCTION symbols, the entry point is in LP_1
+		   and the descriptor in LP_2.  For other symbols, the
+		   unique value is in LP_2.  */
+		symbol->value = bfd_getl64 (vms_rec + EGST_S_Q_LP_2);
+
+		/* Adding this offset is necessary in order for GDB to
+		   read the DWARF-2 debug info from shared libraries.  */
+		if (abfd->flags & DYNAMIC
+		    && strstr (symbol->name, "$DWARF2.DEBUG") != 0)
+		  symbol->value += PRIV (symvva);
+	      }
+	    else /* symbol reference */
+	      (*_bfd_error_handler) ("Invalid EGST reference");
+
+	    symbol->flags = new_flags;
+
+	    if (register_universal_symbol (abfd, symbol, old_flags) < 0)
+	      return -1;
+
+	    /* Make a second symbol for the entry point.  */
+	    if (symbol->flags & BSF_FUNCTION)
+	      {
+		asymbol *en_sym;
+		char *name = bfd_alloc (abfd, strlen (symbol->name) + 5);
+
+		en_sym = bfd_make_empty_symbol (abfd);
+		if (en_sym == 0)
+		  return -1;
+
+		strcpy (name, symbol->name);
+		strcat (name, "..en");
+
+		en_sym->name = name;
+		en_sym->value = bfd_getl64 (vms_rec + EGST_S_Q_LP_1);
+
+		if (register_universal_symbol (abfd, en_sym, old_flags) < 0)
+		  return -1;
+	      }
+	  }
 	  break;
 
+	case EGSD_S_C_IDC + EVAX_OFFSET:
+  	  break;
+
 	default:
-	  (*_bfd_error_handler) (_("unknown gsd/egsd subtype %d"), gsd_type);
+	  (*_bfd_error_handler) (_("Unknown GSD/EGSD subtype %d"), gsd_type);
 	  bfd_set_error (bfd_error_bad_value);
 	  return -1;
 	}
@@ -691,7 +766,79 @@ _bfd_vms_slurp_gsd (bfd * abfd, int objtype)
   return 0;
 }
 
-/* Output routines.  */
+/* Register a universal symbol in the VMS symbol table.  */
+
+static int
+register_universal_symbol (bfd *abfd, asymbol *symbol, int vms_flags)
+{
+  bfd_vma sbase = 0;
+  asection *s, *sec = NULL;
+  vms_symbol_entry *entry;
+
+  /* A universal symbol is by definition global...  */
+  symbol->flags |= BSF_GLOBAL;
+
+  /* ...and dynamic in shared libraries.  */
+  if (abfd->flags & DYNAMIC)
+    symbol->flags |= BSF_DYNAMIC;
+
+  /* Find containing section.  */
+  for (s = abfd->sections; s; s = s->next)
+    {
+      if (symbol->value >= s->vma
+	  && s->vma > sbase
+	  && !(s->flags & SEC_COFF_SHARED_LIBRARY)
+	  && (s->size > 0 || !(vms_flags & EGSY_S_V_REL)))
+	{
+	  sbase = s->vma;
+	  sec = s;
+	}
+    }
+
+  symbol->value -= sbase;
+  symbol->section = sec;
+
+#if VMS_DEBUG
+  vms_debug (4, "EGST sym def #%d (%s, 0x%llx => 0x%llx, %04x=%s)\n",
+	     abfd->symcount, symbol->name, symbol->value + sbase,
+	     symbol->value, vms_flags,
+	     flag2str(gsyflagdesc, vms_flags));
+#endif
+
+  entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
+						symbol->name,
+						TRUE, FALSE);
+
+  if (entry == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return -1;
+    }
+
+  if (entry->symbol) /* FIXME: DEC C generates this */
+    {
+#if VMS_DEBUG
+      vms_debug (4, "EGSD_S_C_SYMG: duplicate \"%s\"\n", symbol->name);
+#endif
+    }
+  else
+    {
+      entry->symbol = symbol;
+      PRIV (gsd_sym_count)++;
+      abfd->symcount++;
+    }
+
+  return 0;
+}
+
+/* Set section VMS flags.  */
+
+void
+bfd_vms_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
+			   asection *sec, flagword flags)
+{
+  vms_section_data (sec)->vflags = flags;
+}
 
 /* Write section and symbol directory of bfd abfd.  */
 
@@ -705,6 +852,7 @@ _bfd_vms_write_gsd (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
   char dummy_name[10];
   char *sname;
   flagword new_flags, old_flags;
+  int abs_section_index = 0;
 
 #if VMS_DEBUG
   vms_debug (2, "vms_write_gsd (%p, %d)\n", abfd, objtype);
@@ -730,6 +878,11 @@ _bfd_vms_write_gsd (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
       vms_debug (3, "Section #%d %s, %d bytes\n", section->index, section->name, (int)section->size);
 #endif
 
+      /* Don't write out the VMS debug info section since it is in the
+         ETBT and EDBG sections in etir. */
+      if (!strcmp (section->name, ".vmsdebug"))
+        goto done;
+
       /* 13 bytes egsd, max 31 chars name -> should be 44 bytes.  */
       if (_bfd_vms_output_check (abfd, 64) < 0)
 	{
@@ -775,6 +928,11 @@ _bfd_vms_write_gsd (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
 	    sname = EVAX_READONLY_NAME;
 	  else if ((*sname == 'l') && (strcmp (sname, "literal") == 0))
 	    sname = EVAX_LITERAL_NAME;
+	  else if ((*sname == 'l') && (strcmp (sname, "literals") == 0))
+	    {
+	      sname = EVAX_LITERALS_NAME;
+	      abs_section_index = section->index;
+	    }
 	  else if ((*sname == 'c') && (strcmp (sname, "comm") == 0))
 	    sname = EVAX_COMMON_NAME;
 	  else if ((*sname == 'l') && (strcmp (sname, "lcomm") == 0))
@@ -785,18 +943,34 @@ _bfd_vms_write_gsd (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
 
       _bfd_vms_output_begin (abfd, EGSD_S_C_PSC, -1);
       _bfd_vms_output_short (abfd, section->alignment_power & 0xff);
+
       if (bfd_is_com_section (section))
-	new_flags = (EGPS_S_V_OVR | EGPS_S_V_REL | EGPS_S_V_GBL | EGPS_S_V_RD | EGPS_S_V_WRT | EGPS_S_V_NOMOD | EGPS_S_V_COM);
+	new_flags = (EGPS_S_V_OVR | EGPS_S_V_REL | EGPS_S_V_GBL | EGPS_S_V_RD
+		     | EGPS_S_V_WRT | EGPS_S_V_NOMOD | EGPS_S_V_COM);
       else
 	new_flags = vms_esecflag_by_name (evax_section_flags, sname,
 					  section->size > 0);
 
+      /* Modify them as directed.  */
+      if (section->flags & SEC_READONLY)
+	new_flags &= ~EGPS_S_V_WRT;
+
+      new_flags |= vms_section_data (section)->vflags & 0xffff;
+      new_flags &=
+	~((vms_section_data (section)->vflags >> EGPS_S_V_NO_SHIFT) & 0xffff);
+
+#if VMS_DEBUG
+      vms_debug (3, "sec flags %x\n", section->flags);
+      vms_debug (3, "new_flags %x, _raw_size %d\n", new_flags, section->size);
+#endif
+
       _bfd_vms_output_short (abfd, new_flags);
       _bfd_vms_output_long (abfd, (unsigned long) section->size);
       _bfd_vms_output_counted (abfd, sname);
       _bfd_vms_output_flush (abfd);
 
       last_index = section->index;
+done:
       section = section->next;
     }
 
@@ -822,9 +996,11 @@ _bfd_vms_write_gsd (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
       if (old_flags & BSF_FILE)
 	continue;
 
-      if (((old_flags & (BSF_GLOBAL | BSF_WEAK)) == 0)	/* Not xdef...  */
-	  && (!bfd_is_und_section (symbol->section)))	/* ...and not xref.  */
-	continue;					/* Dont output.  */
+      if ((old_flags & BSF_GLOBAL) == 0		   /* Not xdef...  */
+	  && !bfd_is_und_section (symbol->section) /* and not xref... */
+	  && !((old_flags & BSF_SECTION_SYM) != 0  /* and not LIB$INITIALIZE.  */
+	       && strcmp (symbol->section->name, "LIB$INITIALIZE") == 0))
+	continue;
 
       /* 13 bytes egsd, max 64 chars name -> should be 77 bytes.  */
       if (_bfd_vms_output_check (abfd, 80) < 0)
@@ -846,7 +1022,7 @@ _bfd_vms_write_gsd (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
 
       if (old_flags & BSF_WEAK)
 	new_flags |= EGSY_S_V_WEAK;
-      if (bfd_is_com_section (symbol->section))
+      if (bfd_is_com_section (symbol->section))		/* .comm  */
 	new_flags |= (EGSY_S_V_WEAK | EGSY_S_V_COMM);
 
       if (old_flags & BSF_FUNCTION)
@@ -854,7 +1030,7 @@ _bfd_vms_write_gsd (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
 	  new_flags |= EGSY_S_V_NORM;
 	  new_flags |= EGSY_S_V_REL;
 	}
-      if (old_flags & (BSF_GLOBAL | BSF_WEAK))
+      if (old_flags & BSF_GLOBAL)
 	{
 	  new_flags |= EGSY_S_V_DEF;
 	  if (!bfd_is_abs_section (symbol->section))
@@ -862,7 +1038,7 @@ _bfd_vms_write_gsd (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
 	}
       _bfd_vms_output_short (abfd, new_flags);
 
-      if (old_flags & (BSF_GLOBAL | BSF_WEAK))
+      if (old_flags & BSF_GLOBAL)
 	{
 	  /* Symbol definition.  */
 	  uquad code_address = 0;
@@ -871,10 +1047,19 @@ _bfd_vms_write_gsd (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
 
 	  if ((old_flags & BSF_FUNCTION) && symbol->udata.p != NULL)
 	    {
-	      code_address = ((asymbol *) (symbol->udata.p))->value;
-	      ca_psindx = ((asymbol *) (symbol->udata.p))->section->index;
+	      asymbol *sym;
+
+	      if (bfd_get_flavour (abfd) == bfd_target_evax_flavour)
+	        sym = ((struct evax_private_udata_struct *)symbol->udata.p)->enbsym;
+	      else
+	        sym = (asymbol *)symbol->udata.p;
+	      code_address = sym->value;
+	      ca_psindx = sym->section->index;
 	    }
-	  psindx = symbol->section->index;
+	  if (bfd_is_abs_section (symbol->section))
+	    psindx = abs_section_index;
+	  else
+	    psindx = symbol->section->index;
 
 	  _bfd_vms_output_quad (abfd, symbol->value);
 	  _bfd_vms_output_quad (abfd, code_address);
diff --git a/bfd/vms-hdr.c b/bfd/vms-hdr.c
index 11e1af6..6ad84dd 100644
--- a/bfd/vms-hdr.c
+++ b/bfd/vms-hdr.c
@@ -1,14 +1,31 @@
 /* vms-hdr.c -- BFD back-end for VMS/VAX (openVMS/VAX) and
    EVAX (openVMS/Alpha) files.
    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006,
-   2007 Free Software Foundation, Inc.
+   2007, 2008, 2009 Free Software Foundation, Inc.
 
    HDR record handling functions
    EMH record handling functions
-   and
+
    EOM record handling functions
    EEOM record handling functions
 
+   IHD record handling functions
+   EIHD record handling functions
+
+   ISD record handling functions
+   EISD record handling functions
+
+   IHS record handling functions
+   EIHS record handling functions
+
+   DBG record handling functions
+   EDBG record handling functions
+
+   TBT record handling functions
+   ETBT record handling functions
+
+   DST/DMT section handling functions
+
    Written by Klaus K"ampf (kkaempf@rmi.de)
 
    This program is free software; you can redistribute it and/or modify
@@ -39,6 +56,20 @@
 #include <alloca.h>
 #endif
 
+static struct module *new_module (bfd *);
+static void parse_module
+  (bfd *, struct module *, unsigned char *, unsigned int);
+static struct module *build_module_list (bfd *);
+static bfd_boolean module_find_nearest_line
+  (bfd *, struct module *, bfd_vma, const char **, const char **,
+   unsigned int *);
+static int vms_slurp_debug (bfd *);
+
+#define SET_MODULE_PARSED(m) \
+  do { if ((m)->name == NULL) (m)->name = ""; } while (0)
+#define IS_MODULE_PARSED(m) ((m)->name != NULL)
+
+
 /* Read & process emh record
    return 0 on success, -1 on error.  */
 
@@ -85,15 +116,15 @@ _bfd_vms_slurp_hdr (bfd *abfd, int objtype)
       break;
 
     case MHD_S_C_LNM:
-      PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 2));
+      PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
       break;
 
     case MHD_S_C_SRC:
-      PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 2));
+      PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
       break;
 
     case MHD_S_C_TTL:
-      PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 2));
+      PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
       break;
 
     case EMH_S_C_MHD + EVAX_OFFSET:
@@ -110,15 +141,15 @@ _bfd_vms_slurp_hdr (bfd *abfd, int objtype)
       break;
 
     case EMH_S_C_LNM + EVAX_OFFSET:
-      PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 6));
+      PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
       break;
 
     case EMH_S_C_SRC + EVAX_OFFSET:
-      PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 6));
+      PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
       break;
 
     case EMH_S_C_TTL + EVAX_OFFSET:
-      PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 6));
+      PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
       break;
 
     case MHD_S_C_CPR:
@@ -189,6 +220,7 @@ _bfd_vms_write_hdr (bfd *abfd, int objtype)
   unsigned int symnum;
   int had_case = 0;
   int had_file = 0;
+  char version [256];
 
 #if VMS_DEBUG
   vms_debug (2, "vms_write_hdr (%p)\n", abfd);
@@ -213,27 +245,34 @@ _bfd_vms_write_hdr (bfd *abfd, int objtype)
 
       fptr = bfd_get_filename (abfd);
       fname = strdup (fptr);
+
+      /* Strip VMS path.  */
       fout = strrchr (fname, ']');
-      if (fout == 0)
+      if (fout == NULL)
 	fout = strchr (fname, ':');
-      if (fout != 0)
+      if (fout != NULL)
 	fout++;
       else
 	fout = fname;
 
+      /* Strip UNIX path.  */
+      fptr = strrchr (fout, '/');
+      if (fptr != NULL)
+	fout = fptr + 1;
+
       /* Strip .obj suffix.  */
-      fptr = strrchr (fname, '.');
-      if ((fptr != 0)
-	  && (strcasecmp (fptr, ".OBJ") == 0))
+      fptr = strrchr (fout, '.');
+      if (fptr != 0 && strcasecmp (fptr, ".OBJ") == 0)
 	*fptr = 0;
 
+      /* Convert to upper case and truncate at 31 characters.
+         (VMS object file format restricts module name length to 31).  */
       fptr = fout;
       while (*fptr != 0)
 	{
 	  *fptr = TOUPPER (*fptr);
 	  fptr++;
-	  if ((*fptr == ';')
-	     || ((fptr - fout) > 31))
+	  if (*fptr == ';' || (fptr - fout) >= 31)
 	    *fptr = 0;
 	}
       _bfd_vms_output_counted (abfd, fout);
@@ -243,13 +282,14 @@ _bfd_vms_write_hdr (bfd *abfd, int objtype)
     _bfd_vms_output_counted (abfd, "NONAME");
 
   _bfd_vms_output_counted (abfd, BFD_VERSION_STRING);
-  _bfd_vms_output_dump (abfd, get_vms_time_string (), 17);
-  _bfd_vms_output_fill (abfd, 0, 17);
+  _bfd_vms_output_dump (abfd, get_vms_time_string (), EMH_DATE_LENGTH);
+  _bfd_vms_output_fill (abfd, 0, EMH_DATE_LENGTH);
   _bfd_vms_output_flush (abfd);
 
   /* LMN.  */
   _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_LNM);
-  _bfd_vms_output_dump (abfd, (unsigned char *) STRING_COMMA_LEN ("GAS proGIS"));
+  snprintf (version, sizeof (version), "GAS BFD v%s", BFD_VERSION_STRING);
+  _bfd_vms_output_dump (abfd, (unsigned char *)version, strlen (version));
   _bfd_vms_output_flush (abfd);
 
   /* SRC.  */
@@ -320,10 +360,10 @@ _bfd_vms_slurp_eom (bfd *abfd, int objtype)
     }
   else
     {
-      PRIV (eom_data).eom_l_total_lps = bfd_getl32 (vms_rec + 4);
-      PRIV (eom_data).eom_b_comcod = *(vms_rec + 8);
-
-      if (PRIV (eom_data).eom_b_comcod > 1)
+      PRIV (eom_data).eom_l_total_lps
+        = bfd_getl32 (vms_rec + EEOM_S_L_TOTAL_LPS);
+      PRIV (eom_data).eom_w_comcod = bfd_getl16 (vms_rec + EEOM_S_W_COMCOD);
+      if (PRIV (eom_data).eom_w_comcod > 1)
 	{
 	  (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
 	  bfd_set_error (bfd_error_bad_value);
@@ -333,9 +373,11 @@ _bfd_vms_slurp_eom (bfd *abfd, int objtype)
       if (PRIV (rec_size) > 10)
 	{
 	   PRIV (eom_data).eom_has_transfer = TRUE;
-	   PRIV (eom_data).eom_b_tfrflg = *(vms_rec + 9);
-	   PRIV (eom_data).eom_l_psindx = bfd_getl32 (vms_rec + 12);
-	   PRIV (eom_data).eom_l_tfradr = bfd_getl32 (vms_rec + 16);
+	   PRIV (eom_data).eom_b_tfrflg = vms_rec[EEOM_S_B_TFRFLG];
+	   PRIV (eom_data).eom_l_psindx
+	     = bfd_getl32 (vms_rec + EEOM_S_L_PSINDX);
+	   PRIV (eom_data).eom_l_tfradr
+	     = bfd_getl32 (vms_rec + EEOM_S_L_TFRADR);
 
 	   abfd->start_address = PRIV (eom_data).eom_l_tfradr;
 	}
@@ -377,3 +419,1001 @@ _bfd_vms_write_eom (bfd *abfd, int objtype)
   _bfd_vms_output_end (abfd);
   return 0;
 }
+
+/* Read & process IHD/EIHD record.
+   Return 0 on success, -1 on error  */
+int
+_bfd_vms_slurp_ihd (bfd *abfd, unsigned int *isd_offset,
+		    unsigned int *ihs_offset)
+{
+  unsigned int imgtype, size;
+  bfd_vma symvva;
+
+#if VMS_DEBUG
+  vms_debug (8, "_bfd_vms_slurp_ihd\n");
+#endif
+
+  size = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SIZE);
+  imgtype = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_IMGTYPE);
+
+  if (imgtype == EIHD_S_K_EXE)
+    abfd->flags |= EXEC_P;
+
+  symvva = bfd_getl64 (PRIV (vms_rec) + EIHD_S_Q_SYMVVA);
+  if (symvva != 0)
+    {
+      PRIV (symvva) = symvva;
+      abfd->flags |= DYNAMIC;
+    }
+
+  *isd_offset = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_ISDOFF);
+  *ihs_offset = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SYMDBGOFF);
+
+#if VMS_DEBUG
+  vms_debug (4, "EIHD record size %d imgtype %d symvva 0x%llx isd %d ihs %d\n",
+	     size, imgtype, symvva, *isd_offset, *ihs_offset);
+#endif
+
+  return 0;
+}
+
+/* Read & process ISD/EISD record
+   return 0 on success, -1 on error  */
+
+int
+_bfd_vms_slurp_isd (bfd *abfd, unsigned int offset)
+{
+  int section_count = 0;
+  unsigned char *p;
+  unsigned int rec_size;
+
+#if VMS_DEBUG
+  vms_debug (8, "_bfd_vms_slurp_isd\n");
+#endif
+
+  for (p = PRIV (vms_rec) + offset;
+       (rec_size = bfd_getl32 (p + EISD_S_L_EISDSIZE)) != 0;
+       p += rec_size)
+    {
+      unsigned long long vaddr = bfd_getl64 (p + EISD_S_Q_VIR_ADDR);
+      unsigned int size = bfd_getl32 (p + EISD_S_L_SECSIZE);
+      unsigned int flags = bfd_getl32 (p + EISD_S_L_FLAGS);
+      unsigned int vbn = bfd_getl32 (p + EISD_S_L_VBN);
+      char *name = NULL;
+      asection *section;
+      flagword bfd_flags;
+
+#if VMS_DEBUG
+      vms_debug (4, "EISD record at 0x%x size 0x%x addr 0x%x bfd_flags 0x%x block %d\n",
+		 p - PRIV (vms_rec), size, vaddr, flags, vbn);
+#endif
+
+      /* VMS combines psects from .obj files into isects in the .exe.  This
+	 process doesn't preserve enough information to reliably determine
+	 what's in each section without examining the data.  This is
+	 especially true of DWARF debug sections.  */
+      bfd_flags = SEC_ALLOC;
+
+      if (flags & EISD_S_M_EXE)
+	bfd_flags |= SEC_CODE | SEC_HAS_CONTENTS | SEC_LOAD;
+
+      if (flags & EISD_S_M_NONSHRADR)
+	bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
+
+      if (!(flags & EISD_S_M_WRT))
+	bfd_flags |= SEC_READONLY;
+
+      if (flags & EISD_S_M_DZRO)
+	bfd_flags |= SEC_DATA;
+
+      if (flags & EISD_S_M_FIXUPVEC)
+	bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
+
+      if (flags & EISD_S_M_CRF)
+	bfd_flags |= SEC_HAS_CONTENTS | SEC_LOAD;
+
+      if (flags & EISD_S_M_GBL)
+	{
+	  name = _bfd_vms_save_counted_string (p + EISD_S_T_GBLNAM);
+	  bfd_flags |= SEC_COFF_SHARED_LIBRARY;
+	  bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);
+	}
+      else
+	{
+	  name = (char*) bfd_alloc (abfd, 32);
+	  sprintf (name, "$LOCAL_%03d$", section_count++);
+	}
+
+      section = bfd_make_section (abfd, name);
+
+      if (!section)
+	return -1;
+
+      section->filepos = vbn ? VMS_BLOCK_SIZE * (vbn - 1) : (unsigned int)-1;
+      section->size = size;
+      section->vma = vaddr;
+
+      if (!bfd_set_section_flags (abfd, section, bfd_flags))
+	return -1;
+    }
+
+  return 0;
+}
+
+/* Read & process IHS/EIHS record
+   return 0 on success, -1 on error  */
+int
+_bfd_vms_slurp_ihs (bfd *abfd, unsigned int offset)
+{
+  unsigned char *p = PRIV (vms_rec) + offset;
+  unsigned int gstvbn = bfd_getl32 (p + EIHS_S_L_GSTVBN);
+  unsigned int gstsize ATTRIBUTE_UNUSED = bfd_getl32 (p + EIHS_S_L_GSTSIZE);
+  unsigned int dstvbn = bfd_getl32 (p + EIHS_S_L_DSTVBN);
+  unsigned int dstsize = bfd_getl32 (p + EIHS_S_L_DSTSIZE);
+  unsigned int dmtvbn = bfd_getl32 (p + EIHS_S_L_DMTVBN);
+  unsigned int dmtbytes = bfd_getl32 (p + EIHS_S_L_DMTBYTES);
+  asection *section;
+
+#if VMS_DEBUG
+  vms_debug (8, "_bfd_vms_slurp_ihs\n");
+  vms_debug (4, "EIHS record gstvbn %d gstsize %d dstvbn %d dstsize %d dmtvbn %d dmtbytes %d\n",
+	     gstvbn, gstsize, dstvbn, dstsize, dmtvbn, dmtbytes);
+#endif
+
+  if (dstvbn)
+    {
+      flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
+
+      section = bfd_make_section (abfd, "$DST$");
+      if (!section)
+	return -1;
+
+      section->size = dstsize;
+      section->filepos = VMS_BLOCK_SIZE * (dstvbn - 1);
+
+      if (!bfd_set_section_flags (abfd, section, bfd_flags))
+	return -1;
+
+      PRIV (dst_section) = section;
+      abfd->flags |= (HAS_DEBUG | HAS_LINENO);
+    }
+
+  if (dmtvbn)
+    {
+      flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
+
+      section = bfd_make_section (abfd, "$DMT$");
+      if (!section)
+	return -1;
+
+      section->size = dmtbytes;
+      section->filepos = VMS_BLOCK_SIZE * (dmtvbn - 1);
+
+      if (!bfd_set_section_flags (abfd, section, bfd_flags))
+	return -1;
+    }
+
+  if (gstvbn)
+    {
+      flagword bfd_flags = SEC_HAS_CONTENTS;
+
+      section = bfd_make_section (abfd, "$GST$");
+      if (!section)
+	return -1;
+
+      if (bfd_seek (abfd, VMS_BLOCK_SIZE * (gstvbn - 1), SEEK_SET))
+	{
+	  bfd_set_error (bfd_error_file_truncated);
+	  return -1;
+	}
+
+      if (_bfd_vms_slurp_object_records (abfd) != 0)
+	return -1;
+
+      section->filepos = VMS_BLOCK_SIZE * (gstvbn - 1);
+      section->size = bfd_tell (abfd) - section->filepos;
+
+      if (!bfd_set_section_flags (abfd, section, bfd_flags))
+	return -1;
+
+      abfd->flags |= HAS_SYMS;
+    }
+
+  return 0;
+}
+
+/* Build a new module for the specified BFD.  */
+
+static struct module *
+new_module (bfd *abfd)
+{
+  struct module *module
+    = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
+  module->file_table_count = 16; /* Arbitrary.  */
+  module->file_table
+    = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
+  return module;
+}
+
+/* Parse debug info for a module and internalize it.  */
+
+static void
+parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
+	      unsigned int length)
+{
+  unsigned char *maxptr = ptr + length, *src_ptr, *pcl_ptr;
+  unsigned int prev_linum = 0, curr_linenum = 0;
+  bfd_vma prev_pc = 0, curr_pc = 0;
+  struct srecinfo *curr_srec, *srec;
+  struct lineinfo *curr_line, *line;
+  struct funcinfo *funcinfo;
+
+  /* Initialize tables with zero element.  */
+  curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
+  module->srec_table = curr_srec;
+
+  curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
+  module->line_table = curr_line;
+
+  while (ptr < maxptr)
+    {
+      /* The first byte is not counted in the recorded length.  */
+      int rec_length = bfd_getl16 (ptr) + 1;
+      int rec_type = bfd_getl16 (ptr + 2);
+
+#if VMS_DEBUG
+      _bfd_vms_debug (2, "DST record: length %d, type %d\n",
+		      rec_length, rec_type);
+#endif
+
+      switch (rec_type)
+	{
+	case DST_S_C_MODBEG:
+	  module->name
+	    = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
+
+	  curr_pc = 0;
+	  prev_pc = 0;
+	  curr_linenum = 0;
+	  prev_linum = 0;
+
+#if VMS_DEBUG
+          _bfd_vms_debug (3, "module: %s\n", module->name);
+#endif
+	  break;
+
+	case DST_S_C_MODEND:
+#if VMS_DEBUG
+          _bfd_vms_debug (3, "end module\n");
+#endif
+	  break;
+
+	case DST_S_C_RTNBEG:
+	  funcinfo = (struct funcinfo *)
+	    bfd_zalloc (abfd, sizeof (struct funcinfo));
+          funcinfo->name
+	    = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
+	  funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
+	  funcinfo->next = module->func_table;
+	  module->func_table = funcinfo;
+    
+#if VMS_DEBUG
+          _bfd_vms_debug (3, "routine: %s at 0x%x\n",
+			  funcinfo->name, funcinfo->low);
+#endif
+	  break;
+
+	case DST_S_C_RTNEND:
+	  module->func_table->high = module->func_table->low
+	    + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
+
+	  if (module->func_table->high > module->high)
+	    module->high = module->func_table->high;
+
+#if VMS_DEBUG
+          _bfd_vms_debug (3, "end routine\n");
+#endif
+	  break;
+
+	case DST_S_C_PROLOG:
+#if VMS_DEBUG
+          _bfd_vms_debug (3, "prologue\n");
+#endif
+	  break;
+
+	case DST_S_C_EPILOG:
+#if VMS_DEBUG
+          _bfd_vms_debug (3, "epilog\n");
+#endif
+	  break;
+
+	case DST_S_C_BLKBEG:
+#if VMS_DEBUG
+          _bfd_vms_debug (3, "block\n");
+#endif
+	  break;
+
+	case DST_S_C_BLKEND:
+#if VMS_DEBUG
+          _bfd_vms_debug (3, "end block\n");
+#endif
+	  break;
+
+	case DST_S_C_SOURCE:
+	  src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
+
+#if VMS_DEBUG
+	  _bfd_vms_debug (3, "source info\n");
+#endif
+
+	  while (src_ptr < ptr + rec_length)
+	    {
+	      int cmd = src_ptr[0], cmd_length, data;
+
+	      switch (cmd)
+		{
+		case DST_S_C_SRC_DECLFILE:
+		  {
+		    unsigned int fileid
+		      = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
+		    char *filename
+		      = _bfd_vms_save_counted_string (src_ptr
+			  + DST_S_B_SRC_DF_FILENAME);
+
+		    while (fileid >= module->file_table_count)
+		      {
+			module->file_table_count *= 2;
+			module->file_table
+			  = bfd_realloc (module->file_table,
+					 module->file_table_count
+					   * sizeof (struct fileinfo));
+		      }
+
+		    module->file_table [fileid].name = filename;
+		    module->file_table [fileid].srec = 1;
+		    cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
+#if VMS_DEBUG
+		    _bfd_vms_debug (4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
+				    fileid,
+				    module->file_table [fileid].name);
+#endif
+		  }
+		  break;
+
+		case DST_S_C_SRC_DEFLINES_B:
+		  /* Perform the association and set the next higher index
+		     to the limit.  */
+		  data = src_ptr[DST_S_B_SRC_UNSBYTE];
+		  srec = (struct srecinfo *)
+		    bfd_zalloc (abfd, sizeof (struct srecinfo));
+		  srec->line = curr_srec->line + data;
+		  srec->srec = curr_srec->srec + data;
+		  srec->sfile = curr_srec->sfile;
+		  curr_srec->next = srec;
+		  curr_srec = srec;
+		  cmd_length = 2;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SRC_DEFLINES_B: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SRC_DEFLINES_W:
+		  /* Perform the association and set the next higher index
+		     to the limit.  */
+		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
+		  srec = (struct srecinfo *)
+		    bfd_zalloc (abfd, sizeof (struct srecinfo));
+		  srec->line = curr_srec->line + data;
+		  srec->srec = curr_srec->srec + data,
+		  srec->sfile = curr_srec->sfile;
+		  curr_srec->next = srec;
+		  curr_srec = srec;
+		  cmd_length = 3;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SRC_DEFLINES_W: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SRC_INCRLNUM_B:
+		  data = src_ptr[DST_S_B_SRC_UNSBYTE];
+		  curr_srec->line += data;
+		  cmd_length = 2;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SRC_SETFILE:
+		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
+		  curr_srec->sfile = data;
+		  curr_srec->srec = module->file_table[data].srec;
+		  cmd_length = 3;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SRC_SETFILE: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SRC_SETLNUM_L:
+		  data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
+		  curr_srec->line = data;
+		  cmd_length = 5;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SRC_SETLNUM_L: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SRC_SETLNUM_W:
+		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
+		  curr_srec->line = data;
+		  cmd_length = 3;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SRC_SETLNUM_W: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SRC_SETREC_L:
+		  data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
+		  curr_srec->srec = data;
+		  module->file_table[curr_srec->sfile].srec = data;
+		  cmd_length = 5;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SRC_SETREC_L: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SRC_SETREC_W:
+		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
+		  curr_srec->srec = data;
+		  module->file_table[curr_srec->sfile].srec = data;
+		  cmd_length = 3;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SRC_SETREC_W: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SRC_FORMFEED:
+		  cmd_length = 1;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SRC_FORMFEED\n");
+#endif
+		  break;
+
+		default:
+		  (*_bfd_error_handler) (_("unknown source command %d"),
+					 cmd);
+		  cmd_length = 2;
+		  break;
+		}
+
+	      src_ptr += cmd_length;
+	    }
+	  break;
+
+	case DST_S_C_LINE_NUM:
+	  pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
+
+#if VMS_DEBUG
+	  _bfd_vms_debug (3, "line info\n");
+#endif
+
+	  while (pcl_ptr < ptr + rec_length)
+	    {
+	      /* The command byte is signed so we must sign-extend it.  */
+	      int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
+
+	      switch (cmd)
+		{
+		case DST_S_C_DELTA_PC_W:
+		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
+		  curr_pc += data;
+		  curr_linenum += 1;
+		  cmd_length = 3;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_DELTA_PC_W: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_DELTA_PC_L:
+		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
+		  curr_pc += data;
+		  curr_linenum += 1;
+		  cmd_length = 5;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_DELTA_PC_L: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_INCR_LINUM:
+		  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
+		  curr_linenum += data;
+		  cmd_length = 2;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_INCR_LINUM: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_INCR_LINUM_W:
+		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
+		  curr_linenum += data;
+		  cmd_length = 3;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_INCR_LINUM_W: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_INCR_LINUM_L:
+		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
+		  curr_linenum += data;
+		  cmd_length = 5;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_INCR_LINUM_L: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SET_LINUM_INCR:
+		  (*_bfd_error_handler)
+		    (_("DST_S_C_SET_LINUM_INCR not implemented"));
+		  cmd_length = 2;
+		  break;
+
+		case DST_S_C_SET_LINUM_INCR_W:
+		  (*_bfd_error_handler)
+		    (_("DST_S_C_SET_LINUM_INCR_W not implemented"));
+		  cmd_length = 3;
+		  break;
+
+		case DST_S_C_RESET_LINUM_INCR:
+		  (*_bfd_error_handler)
+		    (_("DST_S_C_RESET_LINUM_INCR not implemented"));
+		  cmd_length = 1;
+		  break;
+
+		case DST_S_C_BEG_STMT_MODE:
+		  (*_bfd_error_handler)
+		    (_("DST_S_C_BEG_STMT_MODE not implemented"));
+		  cmd_length = 1;
+		  break;
+
+		case DST_S_C_END_STMT_MODE:
+		  (*_bfd_error_handler)
+		    (_("DST_S_C_END_STMT_MODE not implemented"));
+		  cmd_length = 1;
+		  break;
+
+		case DST_S_C_SET_LINUM_B:
+		  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
+		  curr_linenum = data;
+		  cmd_length = 2;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SET_LINUM_B: %d\n", data);
+#endif
+		  break;
+	
+		case DST_S_C_SET_LINE_NUM:
+		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
+		  curr_linenum = data;
+		  cmd_length = 3;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SET_LINE_NUM: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SET_LINUM_L:
+		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
+		  curr_linenum = data;
+		  cmd_length = 5;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SET_LINUM_L: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SET_PC:
+		  (*_bfd_error_handler)
+		    (_("DST_S_C_SET_PC not implemented"));
+		  cmd_length = 2;
+		  break;
+
+		case DST_S_C_SET_PC_W:
+		  (*_bfd_error_handler)
+		    (_("DST_S_C_SET_PC_W not implemented"));
+		  cmd_length = 3;
+		  break;
+
+		case DST_S_C_SET_PC_L:
+		  (*_bfd_error_handler)
+		    (_("DST_S_C_SET_PC_L not implemented"));
+		  cmd_length = 5;
+		  break;
+
+		case DST_S_C_SET_STMTNUM:
+		  (*_bfd_error_handler)
+		    (_("DST_S_C_SET_STMTNUM not implemented"));
+		  cmd_length = 2;
+		  break;
+
+		case DST_S_C_TERM:
+		  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
+		  curr_pc += data;
+		  cmd_length = 2;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_TERM: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_TERM_W:
+		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
+		  curr_pc += data;
+		  cmd_length = 3;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_TERM_W: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_TERM_L:
+		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
+		  curr_pc += data;
+		  cmd_length = 5;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_TERM_L: %d\n", data);
+#endif
+		  break;
+
+		case DST_S_C_SET_ABS_PC:
+		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
+		  curr_pc = data;
+		  cmd_length = 5;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "DST_S_C_SET_ABS_PC: 0x%x\n", data);
+#endif
+		  break;
+
+		default:
+		  if (cmd <= 0)
+		    {
+		      curr_pc -= cmd;
+		      curr_linenum += 1;
+		      cmd_length = 1;
+#if VMS_DEBUG
+		      _bfd_vms_debug (4, "bump pc to 0x%llx and line to %d\n",
+				      curr_pc, curr_linenum);
+#endif
+		    }
+		  else
+		    {
+		      (*_bfd_error_handler) (_("unknown line command %d"),
+					     cmd);
+		      cmd_length = 2;
+		    }
+		  break;
+		}
+
+	      if ((curr_linenum != prev_linum && curr_pc != prev_pc)
+		  || cmd <= 0
+		  || cmd == DST_S_C_DELTA_PC_L
+		  || cmd == DST_S_C_DELTA_PC_W)
+		{
+		  line = (struct lineinfo *)
+		    bfd_zalloc (abfd, sizeof (struct lineinfo));
+		  line->address = curr_pc;
+		  line->line = curr_linenum;
+
+		  curr_line->next = line;
+		  curr_line = line;
+
+		  prev_linum = curr_linenum;
+		  prev_pc = curr_pc;
+#if VMS_DEBUG
+		  _bfd_vms_debug (4, "-> correlate pc 0x%llx with line %d\n",
+				  curr_pc, curr_linenum);
+#endif
+		}
+
+	      pcl_ptr += cmd_length;
+	    }
+	  break;
+
+	case 0x17: /* Undocumented type used by DEC C to declare equates.  */
+#if VMS_DEBUG
+	  _bfd_vms_debug (3, "undocumented type 0x17\n");
+#endif
+	  break;
+
+	default:
+#if VMS_DEBUG
+	  _bfd_vms_debug (3, "ignoring record\n");
+#endif
+	  break;
+
+	}
+
+      ptr += rec_length;
+    }
+
+  /* Finalize tables with EOL marker.  */
+  srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
+  srec->line = (unsigned int) -1;
+  srec->srec = (unsigned int) -1;
+  curr_srec->next = srec;
+
+  line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
+  line->line = (unsigned int) -1;
+  line->address = (bfd_vma) -1;
+  curr_line->next = line;
+
+  /* Advertise that this module has been parsed.  This is needed
+     because parsing can be either performed at module creation
+     or deferred until debug info is consumed.  */
+  SET_MODULE_PARSED (module);
+}
+
+/* Build the list of modules for the specified BFD.  */
+
+static struct module *
+build_module_list (bfd *abfd)
+{
+  struct module *module, *list = NULL;
+  asection *dmt;
+
+  if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
+    {
+      /* We have a DMT section so this must be an image.  Parse the
+	 section and build the list of modules.  This is sufficient
+	 since we can compute the start address and the end address
+	 of every module from the section contents.  */
+      bfd_size_type size = bfd_get_section_size (dmt);
+      unsigned char *ptr, *end;
+
+      ptr = (unsigned char *) bfd_alloc (abfd, size);
+      if (! ptr)
+	return NULL;
+
+      if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
+	return NULL;
+
+#if VMS_DEBUG
+      _bfd_vms_debug (2, "DMT\n");
+#endif
+
+      end = ptr + size;
+
+      while (ptr < end)
+	{
+	  /* Each header declares a module with its start offset and size
+	     of debug info in the DST section, as well as the count of
+	     program sections (i.e. address spans) it contains.  */
+	  int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
+	  int size = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
+	  int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
+	  ptr += DBG_S_C_DMT_HEADER_SIZE;
+
+#if VMS_DEBUG
+	  _bfd_vms_debug (3, "module: modbeg = %d, size = %d, count = %d\n",
+			  modbeg, size, count);
+#endif
+
+	  /* We create a 'module' structure for each program section since
+	     we only support contiguous addresses in a 'module' structure.
+	     As a consequence, the actual debug info in the DST section is
+	     shared and can be parsed multiple times; that doesn't seem to
+	     cause problems in practice.  */
+	  while (count-- > 0)
+	    {
+	      int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
+	      int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
+	      module = new_module (abfd);
+	      module->modbeg = modbeg;
+	      module->size = size;
+	      module->low = start;
+	      module->high = start + length;
+	      module->next = list;
+	      list = module;
+	      ptr += DBG_S_C_DMT_PSECT_SIZE;
+
+#if VMS_DEBUG
+	      _bfd_vms_debug (4, "section: start = 0x%x, length = %d\n",
+			      start, length);
+#endif
+	    }
+	}
+    }
+  else
+    {
+      /* We don't have a DMT section so this must be an object.  Parse
+	 the module right now in order to compute its start address and
+	 end address.  */
+      module = new_module (abfd);
+      parse_module (abfd, module, PRIV (dst_section)->contents,
+		    PRIV (dst_ptr_end) - PRIV (dst_section)->contents);
+      list = module;
+    }
+
+  return list;
+}
+
+/* Calculate and return the name of the source file and the line nearest
+   to the wanted location in the specified module.  */
+
+static bfd_boolean
+module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
+			  const char **file, const char **func, 
+			  unsigned int *line)
+{
+  struct funcinfo *funcinfo;
+  struct lineinfo *lineinfo;
+  struct srecinfo *srecinfo;
+  bfd_boolean ret = FALSE;
+
+  /* Parse this module if that was not done at module creation.  */
+  if (! IS_MODULE_PARSED (module))
+    {
+      unsigned int size = module->size;
+      unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
+      unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
+
+      if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
+	  || bfd_bread (buffer, size, abfd) != size)
+	{
+	  bfd_set_error (bfd_error_no_debug_section);
+	  return FALSE;
+	}
+
+      parse_module (abfd, module, buffer, size);
+      free (buffer);
+    }
+
+  /* Find out the function (if any) that contains the address.  */
+  for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
+    if (addr >= funcinfo->low && addr <= funcinfo->high)
+      {
+        *func = funcinfo->name;
+	ret = TRUE;
+	break;
+      }
+
+  /* Find out the source file and the line nearest to the address.  */
+  for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
+    if (lineinfo->next && addr < lineinfo->next->address)
+      {
+	for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
+	  if (srecinfo->next && lineinfo->line < srecinfo->next->line)
+	    {
+	      if (srecinfo->sfile > 0)
+		{
+		  *file = module->file_table[srecinfo->sfile].name;
+		  *line = srecinfo->srec + lineinfo->line - srecinfo->line;
+		}
+	      else
+		{
+		  *file = module->name;
+		  *line = lineinfo->line;
+		}
+	      return TRUE;
+	    }
+
+	break;
+      }
+
+  return ret;
+}
+
+/* Provided a BFD, a section and an offset into the section, calculate and
+   return the name of the source file and the line nearest to the wanted
+   location.  */
+
+bfd_boolean
+_bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
+				asymbol **symbols ATTRIBUTE_UNUSED,
+				bfd_vma offset, const char **file,
+				const char **func, unsigned int *line)
+{
+  struct module *module;
+
+  /* What address are we looking for?  */
+  bfd_vma addr = section->vma + offset;
+
+  *file = NULL;
+  *func = NULL;
+  *line = 0;
+
+  if (PRIV (dst_section) == NULL)
+    return FALSE;
+
+  if (PRIV (modules) == NULL)
+    {
+      PRIV (modules) = build_module_list (abfd);
+      if (PRIV (modules) == NULL)
+        return FALSE;
+    }
+
+  for (module = PRIV (modules); module; module = module->next)
+    if (addr >= module->low && addr <= module->high)
+      return module_find_nearest_line (abfd, module, addr, file, func, line);
+
+  return FALSE;
+}
+
+/* Process EDBG/ETBT record.
+   Return 0 on success, -1 on error  */
+
+static int
+vms_slurp_debug (bfd *abfd)
+{
+  if (PRIV (dst_section) == NULL)
+    {
+      /* We have no way to find out beforehand how much debug info there
+	 is in an object file, so pick an initial amount and grow it as
+	 needed later.  */
+      flagword flags = SEC_HAS_CONTENTS | SEC_DEBUGGING | SEC_RELOC;
+      asection *section = bfd_make_section (abfd, "$DST$");
+      if (!section)
+	return -1;
+      section->size = 1024;
+      if (!bfd_set_section_flags (abfd, section, flags))
+	return -1;
+      section->contents = ((unsigned char *)
+			   bfd_zmalloc (section->size));
+      if (section->contents == NULL)
+	return -1;
+      section->filepos = (unsigned int)-1;
+      PRIV (dst_section) = section;
+    }
+
+  PRIV (image_section) = PRIV (dst_section);
+  PRIV (image_ptr) = PRIV (dst_section)->contents;
+ 
+  return _bfd_vms_slurp_tir (abfd, EOBJ_S_C_ETIR);
+}
+
+/* Process DBG/EDBG record.
+   Return 0 on success, -1 on error.  */
+
+int
+_bfd_vms_slurp_dbg (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
+{
+#if VMS_DEBUG
+  _bfd_vms_debug (2, "DBG/EDBG\n");
+#endif
+
+  abfd->flags |= (HAS_DEBUG | HAS_LINENO);
+
+  return vms_slurp_debug (abfd);
+}
+
+/* Process TBT/ETBT record.
+   Return 0 on success, -1 on error.  */
+
+int
+_bfd_vms_slurp_tbt (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
+{
+#if VMS_DEBUG
+  _bfd_vms_debug (2, "TBT/ETBT\n");
+#endif
+
+  abfd->flags |= HAS_LINENO;
+
+  return vms_slurp_debug (abfd);
+}
+
+/* Write DBG/EDBG record.  */
+
+int
+_bfd_vms_write_dbg (bfd *abfd ATTRIBUTE_UNUSED, int objtype ATTRIBUTE_UNUSED)
+{
+#if VMS_DEBUG
+  _bfd_vms_debug (2, "vms_write_dbg (%p, objtype)\n", abfd, objtype);
+#endif
+
+  return 0;
+}
+
+/* Write TBT/ETBT record.  */
+
+int
+_bfd_vms_write_tbt (bfd *abfd ATTRIBUTE_UNUSED, int objtype ATTRIBUTE_UNUSED)
+{
+#if VMS_DEBUG
+  _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype);
+#endif
+
+  return 0;
+}
diff --git a/bfd/vms-misc.c b/bfd/vms-misc.c
index 9d0ffdb..2181658 100644
--- a/bfd/vms-misc.c
+++ b/bfd/vms-misc.c
@@ -1,7 +1,9 @@
-/* vms-misc.c -- Miscellaneous functions for VAX (openVMS/VAX) and
+/* vms-misc.c -- BFD back-end for VMS/VAX (openVMS/VAX) and
    EVAX (openVMS/Alpha) files.
    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-   2007, 2008  Free Software Foundation, Inc.
+   2007, 2008, 2009  Free Software Foundation, Inc.
+
+   Miscellaneous functions.
 
    Written by Klaus K"ampf (kkaempf@rmi.de)
 
@@ -30,22 +32,29 @@
 #include "libbfd.h"
 
 #include "vms.h"
-
+
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+
+static int hash_string PARAMS ((const char *));
+static asymbol *new_symbol PARAMS ((bfd *, char *));
+static void maybe_adjust_record_pointer_for_object PARAMS ((bfd *));
+static int vms_get_remaining_object_record PARAMS ((bfd *, int ));
+static int vms_get_remaining_image_record PARAMS ((bfd *, int ));
+
 #if VMS_DEBUG
 /* Debug functions.  */
 
-/* Debug function for all vms extensions
-   evaluates environment variable VMS_DEBUG for a
-   numerical value on the first call
-   all error levels below this value are printed
+/* Debug function for all vms extensions evaluates environment
+   variable VMS_DEBUG for a numerical value on the first call all
+   error levels below this value are printed:
 
-   levels:
+   Levels:
    1	toplevel bfd calls (functions from the bfd vector)
    2	functions called by bfd calls
    ...
    9	almost everything
 
-   level is also indentation level. Indentation is performed
+   Level is also indentation level. Indentation is performed
    if level > 0.  */
 
 void
@@ -167,22 +176,23 @@ _bfd_vms_hash_newfunc (struct bfd_hash_entry *entry,
 
 /* Object file input functions.  */
 
-/* Return type and length from record header (buf) on Alpha.  */
+/* Return type and size from record header (buf) on Alpha.  */
 
 void
 _bfd_vms_get_header_values (bfd * abfd ATTRIBUTE_UNUSED,
 			    unsigned char *buf,
 			    int *type,
-			    int *length)
+			    int *size)
 {
-  if (type != 0)
+  if (type)
     *type = bfd_getl16 (buf);
-  buf += 2;
-  if (length != 0)
-    *length = bfd_getl16 (buf);
+
+  if (size)
+    *size = bfd_getl16 (buf+2);
 
 #if VMS_DEBUG
-  vms_debug (10, "_bfd_vms_get_header_values type %x, length %x\n", (type?*type:0), (length?*length:0));
+  vms_debug (10, "_bfd_vms_get_header_values type %x, size %x\n",
+	     type ? *type : 0, size ? *size : 0);
 #endif
 }
 
@@ -193,237 +203,341 @@ _bfd_vms_get_header_values (bfd * abfd ATTRIBUTE_UNUSED,
 
    The openVMS object file has 'variable length' which means that
    read() returns data in chunks of (hopefully) correct and expected
-   size. The linker (and other tools on vms) depend on that. Unix doesn't
-   know about 'formatted' files, so reading and writing such an object
-   file in a unix environment is not trivial.
+   size.  The linker (and other tools on VMS) depend on that. Unix
+   doesn't know about 'formatted' files, so reading and writing such
+   an object file in a Unix environment is not trivial.
 
-   With the tool 'file' (available on all vms ftp sites), one
-   can view and change the attributes of a file. Changing from
+   With the tool 'file' (available on all VMS FTP sites), one
+   can view and change the attributes of a file.  Changing from
    'variable length' to 'fixed length, 512 bytes' reveals the
-   record length at the first 2 bytes of every record. The same
-   happens during the transfer of object files from vms to unix,
-   at least with ucx, dec's implementation of tcp/ip.
+   record size at the first 2 bytes of every record.  The same
+   happens during the transfer of object files from VMS to Unix,
+   at least with UCX, the DEC implementation of TCP/IP.
 
-   The vms format repeats the length at bytes 2 & 3 of every record.
+   The VMS format repeats the size at bytes 2 & 3 of every record.
 
    On the first call (file_format == FF_UNKNOWN) we check if
    the first and the third byte pair (!) of the record match.
-   If they do it's an object file in an unix environment or with
-   wrong attributes (FF_FOREIGN), else we should be in a vms
+   If they do it's an object file in an Unix environment or with
+   wrong attributes (FF_FOREIGN), else we should be in a VMS
    environment where read() returns the record size (FF_NATIVE).
 
-   Reading is always done in 2 steps.
-   First just the record header is read and the length extracted
-   by get_header_values,
-   then the read buffer is adjusted and the remaining bytes are
-   read in.
+   Reading is always done in 2 steps:
+    1. first just the record header is read and the size extracted,
+    2. then the read buffer is adjusted and the remaining bytes are
+       read in.
+
+   All file I/O is done on even file positions.  */
 
-   All file i/o is always done on even file positions.  */
+#define VMS_OBJECT_ADJUSTMENT  2
+
+static void
+maybe_adjust_record_pointer_for_object (bfd *abfd)
+{
+  /* Set the file format once for all on the first invocation.  */
+  if (PRIV (file_format) == FF_UNKNOWN)
+    {
+      if (PRIV (vms_rec)[0] == PRIV (vms_rec)[4]
+	  && PRIV (vms_rec)[1] == PRIV (vms_rec)[5])
+	PRIV (file_format) = FF_FOREIGN;
+      else
+	PRIV (file_format) = FF_NATIVE;
+    }
+
+  /* The adjustment is needed only in an Unix environment.  */
+  if (PRIV (file_format) == FF_FOREIGN)
+    PRIV (vms_rec) += VMS_OBJECT_ADJUSTMENT;
+}
+
+/* Get first record from file and return the file type.  */
 
 int
-_bfd_vms_get_record (bfd * abfd)
+_bfd_vms_get_first_record (bfd *abfd)
 {
-  int test_len, test_start, remaining;
-  unsigned char *vms_buf;
+  unsigned int test_len;
 
 #if VMS_DEBUG
-  vms_debug (8, "_bfd_vms_get_record\n");
+  vms_debug (8, "_bfd_vms_get_first_record\n");
 #endif
 
-  /* Minimum is 6 bytes on Alpha
-     (2 bytes length, 2 bytes record id, 2 bytes length repeated)
-
-     On the VAX there's no length information in the record
-     so start with OBJ_S_C_MAXRECSIZ.   */
+  if (PRIV (is_vax))
+    test_len = 0;
+  else
+    /* Minimum is 6 bytes for objects (2 bytes size, 2 bytes record id,
+       2 bytes size repeated) and 12 bytes for images (4 bytes major id,
+       4 bytes minor id, 4 bytes length).  */
+    test_len = 12;
 
+  /* Size the main buffer.  */
   if (PRIV (buf_size) == 0)
     {
-      bfd_size_type amt;
-
-      if (PRIV (is_vax))
-	{
-	  amt = OBJ_S_C_MAXRECSIZ;
-	  PRIV (file_format) = FF_VAX;
-	}
-      else
-	amt = 6;
-      PRIV (vms_buf) = bfd_malloc (amt);
+      /* On VAX there's no size information in the record, so
+	 start with OBJ_S_C_MAXRECSIZ.  */
+      bfd_size_type amt = (test_len ? test_len : OBJ_S_C_MAXRECSIZ);
+      PRIV (vms_buf) = (unsigned char *) bfd_malloc (amt);
       PRIV (buf_size) = amt;
     }
 
-  vms_buf = PRIV (vms_buf);
+  /* Initialize the record pointer.  */
+  PRIV (vms_rec) = PRIV (vms_buf);
 
-  if (vms_buf == 0)
-    return -1;
-
-  switch (PRIV (file_format))
+  /* We only support modules on VAX.  */
+  if (PRIV (is_vax))
     {
-    case FF_UNKNOWN:
-    case FF_FOREIGN:
-      test_len = 6;			/* Probe 6 bytes.  */
-      test_start = 2;			/* Where the record starts.  */
-      break;
-
-    case FF_NATIVE:
-      test_len = 4;
-      test_start = 0;
-      break;
-
-    default:
-    case FF_VAX:
-      test_len = 0;
-      test_start = 0;
-      break;
+      if (vms_get_remaining_object_record (abfd, test_len) <= 0)
+	return FT_UNKNOWN;
+
+#if VMS_DEBUG
+      vms_debug (2, "file type is VAX module\n");
+#endif
+
+      return FT_MODULE;
     }
 
-  /* Skip odd alignment byte.  */
+  if (bfd_bread (PRIV (vms_buf), test_len, abfd) != test_len)
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      return FT_UNKNOWN;
+    }
 
-  if (bfd_tell (abfd) & 1)
+  /* Is it an image?  */
+  if ((bfd_getl32 (PRIV (vms_rec)) == EIHD_S_K_MAJORID)
+      && (bfd_getl32 (PRIV (vms_rec) + 4) == EIHD_S_K_MINORID))
     {
-      if (bfd_bread (PRIV (vms_buf), (bfd_size_type) 1, abfd) != 1)
-	{
-	  bfd_set_error (bfd_error_file_truncated);
-	  return 0;
-	}
+      if (vms_get_remaining_image_record (abfd, test_len) <= 0)
+	return FT_UNKNOWN;
+
+#if VMS_DEBUG
+      vms_debug (2, "file type is image\n");
+#endif
+
+      return FT_IMAGE;
     }
 
-  /* Read the record header on Alpha.  */
-  if ((test_len != 0)
-      && (bfd_bread (PRIV (vms_buf), (bfd_size_type) test_len, abfd)
-	  != (bfd_size_type) test_len))
+  /* Assume it's a module and adjust record pointer if necessary.  */
+  maybe_adjust_record_pointer_for_object (abfd);
+
+  /* But is it really a module?  */
+  if (bfd_getl16 (PRIV (vms_rec)) <= EOBJ_S_C_MAXRECTYP
+      && bfd_getl16 (PRIV (vms_rec) + 2) <= EOBJ_S_C_MAXRECSIZ)
     {
-      bfd_set_error (bfd_error_file_truncated);
-      return 0;
+      if (vms_get_remaining_object_record (abfd, test_len) <= 0)
+	return FT_UNKNOWN;
+
+#if VMS_DEBUG
+      vms_debug (2, "file type is module\n");
+#endif
+
+      return FT_MODULE;
     }
 
-  /* Check file format on first call.  */
-  if (PRIV (file_format) == FF_UNKNOWN)
-    {						/* Record length repeats ?  */
-      if (vms_buf[0] == vms_buf[4]
-	  && vms_buf[1] == vms_buf[5])
+#if VMS_DEBUG
+  vms_debug (2, "file type is unknown\n");
+#endif
+
+  return FT_UNKNOWN;
+}
+
+/* Implement step #1 of the object record reading procedure.
+   Return the record type or -1 on failure.  */
+
+int
+_bfd_vms_get_object_record (bfd *abfd)
+{
+  unsigned int test_len;
+  int type;
+
+#if VMS_DEBUG
+  vms_debug (8, "_bfd_vms_get_obj_record\n");
+#endif
+
+  if (PRIV (is_vax))
+    test_len = 0;
+  else
+    {
+      /* See _bfd_vms_get_first_record.  */
+      test_len = 6;
+
+      /* Skip odd alignment byte.  */
+      if (bfd_tell (abfd) & 1)
 	{
-	  PRIV (file_format) = FF_FOREIGN;	/* Y: foreign environment.  */
-	  test_start = 2;
+	  if (bfd_bread (PRIV (vms_buf), 1, abfd) != 1)
+	    {
+	      bfd_set_error (bfd_error_file_truncated);
+	      return -1;
+	    }
 	}
-      else
+
+      /* Read the record header  */
+      if (bfd_bread (PRIV (vms_buf), test_len, abfd) != test_len)
 	{
-	  PRIV (file_format) = FF_NATIVE;	/* N: native environment.  */
-	  test_start = 0;
+	  bfd_set_error (bfd_error_file_truncated);
+	  return -1;
 	}
+
+      /* Reset the record pointer.  */
+      PRIV (vms_rec) = PRIV (vms_buf);
+      maybe_adjust_record_pointer_for_object (abfd);
     }
 
+  if (vms_get_remaining_object_record (abfd, test_len) <= 0)
+    return -1;
+
+  if (PRIV (is_vax))
+    type = PRIV (vms_rec) [0];
+  else
+    type = bfd_getl16 (PRIV (vms_rec));
+
+#if VMS_DEBUG
+  vms_debug (8, "_bfd_vms_get_obj_record: rec %p, size %d, type %d\n",
+	      PRIV (vms_rec), PRIV (rec_size), type);
+#endif
+
+  return type;
+}
+
+/* Implement step #2 of the object record reading procedure.
+   Return the size of the record or 0 on failure.  */
+
+static int
+vms_get_remaining_object_record (bfd *abfd, int read_so_far)
+{
+#if VMS_DEBUG
+  vms_debug (8, "vms_get_remaining_obj_record\n");
+#endif
+
   if (PRIV (is_vax))
     {
-      PRIV (rec_length) = bfd_bread (vms_buf, (bfd_size_type) PRIV (buf_size),
-				     abfd);
-      if (PRIV (rec_length) <= 0)
+      if (read_so_far != 0)
+        abort ();
+
+      PRIV (rec_size) = bfd_bread (PRIV (vms_buf), PRIV (buf_size), abfd);
+
+      if (PRIV (rec_size) <= 0)
 	{
 	  bfd_set_error (bfd_error_file_truncated);
 	  return 0;
 	}
-      PRIV (vms_rec) = vms_buf;
+
+      /* Reset the record pointer.  */
+      PRIV (vms_rec) = PRIV (vms_buf);
     }
   else
     {
-      /* Alpha.   */
-      /* Extract vms record length.  */
+      unsigned int to_read;
 
-      _bfd_vms_get_header_values (abfd, vms_buf + test_start, NULL,
-				  & PRIV (rec_length));
+      /* Extract record size.  */
+      PRIV (rec_size) = bfd_getl16 (PRIV (vms_rec) + 2);
 
-      if (PRIV (rec_length) <= 0)
+      if (PRIV (rec_size) <= 0)
 	{
 	  bfd_set_error (bfd_error_file_truncated);
 	  return 0;
 	}
 
       /* That's what the linker manual says.  */
-
-      if (PRIV (rec_length) > EOBJ_S_C_MAXRECSIZ)
+      if (PRIV (rec_size) > EOBJ_S_C_MAXRECSIZ)
 	{
 	  bfd_set_error (bfd_error_file_truncated);
 	  return 0;
 	}
 
-      /* Adjust the buffer.  */
+      /* Take into account object adjustment.  */
+      to_read = PRIV (rec_size);
+      if (PRIV (file_format) == FF_FOREIGN)
+	to_read += VMS_OBJECT_ADJUSTMENT;
 
-      if (PRIV (rec_length) > PRIV (buf_size))
+      /* Adjust the buffer.  */
+      if (to_read > PRIV (buf_size))
 	{
-	  PRIV (vms_buf) = bfd_realloc_or_free (vms_buf,
-					(bfd_size_type) PRIV (rec_length));
-	  vms_buf = PRIV (vms_buf);
-	  if (vms_buf == 0)
-	    return -1;
-	  PRIV (buf_size) = PRIV (rec_length);
+	  PRIV (vms_buf)
+	    = (unsigned char *) bfd_realloc (PRIV (vms_buf), to_read);
+	  if (PRIV (vms_buf) == NULL)
+	    return 0;
+	  PRIV (buf_size) = to_read;
 	}
 
       /* Read the remaining record.  */
-      remaining = PRIV (rec_length) - test_len + test_start;
+      to_read -= read_so_far;
 
 #if VMS_DEBUG
-      vms_debug (10, "bfd_bread remaining %d\n", remaining);
+      vms_debug (8, "vms_get_remaining_obj_record: to_read %d\n", to_read);
 #endif
-      if (bfd_bread (vms_buf + test_len, (bfd_size_type) remaining, abfd) !=
-	  (bfd_size_type) remaining)
+
+      if (bfd_bread (PRIV (vms_buf) + read_so_far, to_read, abfd) != to_read)
 	{
 	  bfd_set_error (bfd_error_file_truncated);
 	  return 0;
 	}
-      PRIV (vms_rec) = vms_buf + test_start;
+
+      /* Reset the record pointer.  */
+      PRIV (vms_rec) = PRIV (vms_buf);
+      maybe_adjust_record_pointer_for_object (abfd);
     }
 
 #if VMS_DEBUG
-  vms_debug (11, "bfd_bread rec_length %d\n", PRIV (rec_length));
+  vms_debug (8, "vms_get_remaining_obj_record: size %d\n", PRIV (rec_size));
 #endif
 
-  return PRIV (rec_length);
+  return PRIV (rec_size);
 }
 
-/* Get next vms record from file
-   update vms_rec and rec_length to new (remaining) values.  */
+/* Implement step #2 of the record reading procedure for images.
+   Return the size of the record or 0 on failure.  */
 
-int
-_bfd_vms_next_record (bfd * abfd)
+static int
+vms_get_remaining_image_record (bfd *abfd, int read_so_far)
 {
-#if VMS_DEBUG
-  vms_debug (8, "_bfd_vms_next_record (len %d, size %d)\n",
-	      PRIV (rec_length), PRIV (rec_size));
-#endif
+  unsigned int to_read;
+  int remaining;
 
-  if (PRIV (rec_length) > 0)
-    PRIV (vms_rec) += PRIV (rec_size);
-  else
+  /* Extract record size.  */
+  PRIV (rec_size) = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SIZE);
+
+  if (PRIV (rec_size) > PRIV (buf_size))
     {
-      if (_bfd_vms_get_record (abfd) <= 0)
-	return -1;
+      PRIV (vms_buf) = bfd_realloc (PRIV (vms_buf), PRIV (rec_size));
+
+      if (PRIV (vms_buf) == NULL)
+	{
+	  bfd_set_error (bfd_error_no_memory);
+	  return 0;
+	}
+
+      PRIV (buf_size) = PRIV (rec_size);
     }
 
-  if (!PRIV (vms_rec) || !PRIV (vms_buf)
-      || PRIV (vms_rec) >= (PRIV (vms_buf) + PRIV (buf_size)))
-    return -1;
+  /* Read the remaining record.  */
+  remaining = PRIV (rec_size) - read_so_far;
+  to_read = MIN (VMS_BLOCK_SIZE - read_so_far, remaining);
 
-  if (PRIV (is_vax))
+  while (remaining > 0)
     {
-      PRIV (rec_type) = *(PRIV (vms_rec));
-      PRIV (rec_size) = PRIV (rec_length);
-    }
-  else
-    _bfd_vms_get_header_values (abfd, PRIV (vms_rec), &PRIV (rec_type),
-				&PRIV (rec_size));
+      if (bfd_bread (PRIV (vms_buf) + read_so_far, to_read, abfd) != to_read)
+	{
+	  bfd_set_error (bfd_error_file_truncated);
+	  return 0;
+	}
 
-  PRIV (rec_length) -= PRIV (rec_size);
+      read_so_far += to_read;
+      remaining -= to_read;
 
-#if VMS_DEBUG
-  vms_debug (8, "_bfd_vms_next_record: rec %p, size %d, length %d, type %d\n",
-	      PRIV (vms_rec), PRIV (rec_size), PRIV (rec_length),
-	      PRIV (rec_type));
-#endif
+      /* Eat trailing 0xff's.  */
+      if (remaining > 0)
+	while (PRIV (vms_buf) [read_so_far - 1] == 0xff)
+	  read_so_far--;
+
+      to_read = MIN (VMS_BLOCK_SIZE, remaining);
+    }
 
-  return PRIV (rec_type);
+  /* Reset the record pointer.  */
+  PRIV (vms_rec) = PRIV (vms_buf);
+
+  return PRIV (rec_size);
 }
-
-/* Copy sized string (string with fixed length) to new allocated area
-   size is string length (size of record)  */
+
+/* Copy sized string (string with fixed size) to new allocated area
+   size is string size (size of record)  */
 
 char *
 _bfd_vms_save_sized_string (unsigned char *str, int size)
@@ -438,8 +552,8 @@ _bfd_vms_save_sized_string (unsigned char *str, int size)
   return newstr;
 }
 
-/* Copy counted string (string with length at first byte) to new allocated area
-   ptr points to length byte on entry  */
+/* Copy counted string (string with size at first byte) to new allocated area
+   ptr points to size byte on entry  */
 
 char *
 _bfd_vms_save_counted_string (unsigned char *ptr)
@@ -501,83 +615,12 @@ _bfd_vms_pop (bfd * abfd, int *psect)
   return value;
 }
 
-/* Object file output functions.  */
-
-/* GAS tends to write sections in little chunks (bfd_set_section_contents)
-   which we can't use directly. So we save the little chunks in linked
-   lists (one per section) and write them later.  */
-
-/* Add a new vms_section structure to vms_section_table
-   - forward chaining -.  */
-
-static vms_section *
-add_new_contents (bfd * abfd, sec_ptr section)
-{
-  vms_section *sptr, *newptr;
-
-  sptr = PRIV (vms_section_table)[section->index];
-  if (sptr != NULL)
-    return sptr;
-
-  newptr = bfd_alloc (abfd, (bfd_size_type) sizeof (vms_section));
-  if (newptr == NULL)
-    return NULL;
-  newptr->contents = bfd_alloc (abfd, section->size);
-  if (newptr->contents == NULL)
-    return NULL;
-  newptr->offset = 0;
-  newptr->size = section->size;
-  newptr->next = 0;
-  PRIV (vms_section_table)[section->index] = newptr;
-  return newptr;
-}
-
-/* Save section data & offset to a vms_section structure
-   vms_section_table[] holds the vms_section chain.  */
-
-bfd_boolean
-_bfd_save_vms_section (bfd * abfd,
-		       sec_ptr section,
-		       const void * data,
-		       file_ptr offset,
-		       bfd_size_type count)
-{
-  vms_section *sptr;
-
-  if (section->index >= VMS_SECTION_COUNT)
-    {
-      bfd_set_error (bfd_error_nonrepresentable_section);
-      return FALSE;
-    }
-  if (count == (bfd_size_type)0)
-    return TRUE;
-  sptr = add_new_contents (abfd, section);
-  if (sptr == NULL)
-    return FALSE;
-  memcpy (sptr->contents + offset, data, (size_t) count);
-
-  return TRUE;
-}
-
-/* Get vms_section pointer to saved contents for section # index  */
-
-vms_section *
-_bfd_get_vms_section (bfd * abfd, int index)
-{
-  if (index >=  VMS_SECTION_COUNT)
-    {
-      bfd_set_error (bfd_error_nonrepresentable_section);
-      return NULL;
-    }
-  return PRIV (vms_section_table)[index];
-}
-
 /* Object output routines.   */
 
 /* Begin new record or record header
    write 2 bytes rectype
    write 2 bytes record length (filled in at flush)
-   write 2 bytes header type (ommitted if rechead == -1).   */
+   write 2 bytes header type (ommitted if rechead == -1).  */
 
 void
 _bfd_vms_output_begin (bfd * abfd, int rectype, int rechead)
@@ -691,18 +734,11 @@ _bfd_vms_output_flush (bfd * abfd)
 
   if (PRIV (push_level) == 0)
     {
-      if (0
-#ifndef VMS
-	  /* Write length first, see FF_FOREIGN in the input routines.  */
-	  || fwrite (PRIV (output_buf) + 2, 2, 1,
-		     (FILE *) abfd->iostream) != 1
-#endif
-	  || (real_size != 0
-	      && fwrite (PRIV (output_buf), (size_t) real_size, 1,
-			 (FILE *) abfd->iostream) != 1))
-	/* FIXME: Return error status.  */
-	abort ();
-
+      /* File is open in undefined (UDF) format on VMS, but ultimately will be
+	 converted to variable length (VAR) format.  VAR format has a length
+	 word first which must be explicitly output in UDF format.  */
+      bfd_bwrite (PRIV (output_buf) + 2, 2, abfd);
+      bfd_bwrite (PRIV (output_buf), (size_t) real_size, abfd);
       PRIV (output_size) = 0;
     }
   else
@@ -948,7 +984,7 @@ new_symbol (bfd * abfd, char *name)
   if (symbol == 0)
     return symbol;
   symbol->name = name;
-  symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME);
+  symbol->section = (asection *)(unsigned long)-1;
 
   return symbol;
 }
diff --git a/bfd/vms-tir.c b/bfd/vms-tir.c
index e6ec6eb..5bc61da 100644
--- a/bfd/vms-tir.c
+++ b/bfd/vms-tir.c
@@ -1,12 +1,12 @@
 /* vms-tir.c -- BFD back-end for VAX (openVMS/VAX) and
    EVAX (openVMS/Alpha) files.
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2008
-   Free Software Foundation, Inc.
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007,
+   2008, 2009 Free Software Foundation, Inc.
 
    TIR record handling functions
    ETIR record handling functions
 
-   go and read the openVMS linker manual (esp. appendix B)
+   Go and read the openVMS linker manual (esp. appendix B)
    if you don't know what's going on here :-)
 
    Written by Klaus K"ampf (kkaempf@rmi.de)
@@ -26,7 +26,6 @@
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
    MA 02110-1301, USA.  */
 
-
 /* The following type abbreviations are used:
 
 	cs	counted string (ascii string with length byte)
@@ -41,6 +40,33 @@
 #include "bfdlink.h"
 #include "libbfd.h"
 #include "vms.h"
+
+static int check_section (bfd *, int);
+static void image_set_ptr (bfd *abfd, int psect, uquad offset);
+static void image_inc_ptr (bfd *abfd, uquad offset);
+static void dst_define_location (bfd *abfd, uquad loc);
+static void dst_restore_location (bfd *abfd, uquad loc);
+static unsigned int dst_retrieve_location (bfd *abfd, uquad loc);
+static void dst_check_allocation (bfd *abfd, unsigned int size);
+static void image_dump (bfd *abfd, unsigned char *ptr, int size, int offset);
+static void image_write_b (bfd *abfd, unsigned int value);
+static void image_write_w (bfd *abfd, unsigned int value);
+static void image_write_l (bfd *abfd, unsigned long value);
+static void image_write_q (bfd *abfd, uquad value);
+static bfd_boolean etir_sta (bfd *, int, unsigned char *, int *);
+static bfd_boolean etir_sto (bfd *, int, unsigned char *, int *);
+static bfd_boolean etir_opr (bfd *, int, unsigned char *, int *);
+static bfd_boolean etir_ctl (bfd *, int, unsigned char *, int *);
+static bfd_boolean etir_stc (bfd *, int, unsigned char *, int *);
+static asection *new_section (bfd *, int);
+static int alloc_section (bfd *, unsigned int);
+static int etir_cmd (bfd *, int, unsigned char *, int *);
+static int analyze_tir (bfd *, unsigned char *, unsigned int);
+static int analyze_etir (bfd *, unsigned char *, unsigned int);
+static unsigned char *tir_opr (bfd *, unsigned char *);
+static const char *tir_cmd_name (int);
+static const char *cmd_name (int);
+
 
 static int
 check_section (bfd * abfd, int size)
@@ -92,6 +118,77 @@ image_inc_ptr (bfd * abfd, uquad offset)
   PRIV (image_ptr) += offset;
 }
 
+/* Save current DST location counter under specified index.  */
+
+static void
+dst_define_location (bfd *abfd, uquad loc)
+{
+  asection *dst_section = PRIV (dst_section);
+
+#if VMS_DEBUG
+  _bfd_vms_debug (4, "dst_define_location (%d)\n", (int)loc);
+#endif
+
+  /* Grow the ptr offset table if necessary.  */
+  if (loc + 1 > PRIV (dst_ptr_offsets_count))
+    {
+      PRIV (dst_ptr_offsets) = bfd_realloc (PRIV (dst_ptr_offsets),
+					   (loc + 1) * sizeof (unsigned int));
+      PRIV (dst_ptr_offsets_count) = loc + 1;
+    }
+
+  PRIV (dst_ptr_offsets)[loc] = PRIV (image_ptr) - dst_section->contents;
+}
+
+/* Restore saved DST location counter from specified index.  */
+
+static void
+dst_restore_location (bfd *abfd, uquad loc)
+{
+  asection *dst_section = PRIV (dst_section);
+
+#if VMS_DEBUG
+  _bfd_vms_debug (4, "dst_restore_location (%d)\n", (int)loc);
+#endif
+
+  PRIV (image_ptr) = dst_section->contents + PRIV (dst_ptr_offsets)[loc];
+}
+
+/* Retrieve saved DST location counter from specified index.  */
+
+static unsigned int
+dst_retrieve_location (bfd *abfd, uquad loc)
+{
+#if VMS_DEBUG
+  _bfd_vms_debug (4, "dst_retrieve_location (%d)\n", (int)loc);
+#endif
+
+  return PRIV (dst_ptr_offsets)[loc];
+}
+
+/* Check that the DST section is big enough for the specified
+   amount of bytes.  */
+
+static void
+dst_check_allocation (bfd *abfd, unsigned int size)
+{
+  asection *dst_section = PRIV (dst_section);
+
+  bfd_size_type used = PRIV (image_ptr) - dst_section->contents;
+  bfd_size_type left = dst_section->size - used;
+
+  /* Grow the DST section as necessary */
+  if (size > left)
+    {
+      dst_section->size *= 2;
+      dst_section->contents
+	= bfd_realloc (dst_section->contents, dst_section->size);
+      PRIV (image_ptr) = dst_section->contents + used;
+
+      dst_check_allocation (abfd, size);
+    }
+}
+
 /* Dump multiple bytes to section image.  */
 
 static void
@@ -109,6 +206,9 @@ image_dump (bfd * abfd,
   if (PRIV (is_vax) && check_section (abfd, size))
     return;
 
+  if (PRIV (dst_section))
+    dst_check_allocation (abfd, size);
+
   while (size-- > 0)
     *PRIV (image_ptr)++ = *ptr++;
 }
@@ -125,6 +225,9 @@ image_write_b (bfd * abfd, unsigned int value)
   if (PRIV (is_vax) && check_section (abfd, 1))
     return;
 
+  if (PRIV (dst_section))
+    dst_check_allocation (abfd, 1);
+
   *PRIV (image_ptr)++ = (value & 0xff);
 }
 
@@ -140,6 +243,9 @@ image_write_w (bfd * abfd, unsigned int value)
   if (PRIV (is_vax) && check_section (abfd, 2))
     return;
 
+  if (PRIV (dst_section))
+    dst_check_allocation (abfd, 2);
+
   bfd_putl16 ((bfd_vma) value, PRIV (image_ptr));
   PRIV (image_ptr) += 2;
 }
@@ -156,6 +262,9 @@ image_write_l (bfd * abfd, unsigned long value)
   if (PRIV (is_vax) && check_section (abfd, 4))
     return;
 
+  if (PRIV (dst_section))
+    dst_check_allocation (abfd, 4);
+
   bfd_putl32 ((bfd_vma) value, PRIV (image_ptr));
   PRIV (image_ptr) += 4;
 }
@@ -172,6 +281,9 @@ image_write_q (bfd * abfd, uquad value)
   if (PRIV (is_vax) && check_section (abfd, 8))
     return;
 
+  if (PRIV (dst_section))
+    dst_check_allocation (abfd, 8);
+
   bfd_putl64 (value, PRIV (image_ptr));
   PRIV (image_ptr) += 8;
 }
@@ -182,6 +294,8 @@ cmd_name (int cmd)
   switch (cmd)
     {
     case ETIR_S_C_STA_GBL: return "ETIR_S_C_STA_GBL";
+    case ETIR_S_C_STA_LW: return "ETIR_S_C_STA_LW";
+    case ETIR_S_C_STA_QW: return "ETIR_S_C_STA_QW";
     case ETIR_S_C_STA_PQ: return "ETIR_S_C_STA_PQ";
     case ETIR_S_C_STA_LI: return "ETIR_S_C_STA_LI";
     case ETIR_S_C_STA_MOD: return "ETIR_S_C_STA_MOD";
@@ -192,10 +306,16 @@ cmd_name (int cmd)
     case ETIR_S_C_STO_CA: return "ETIR_S_C_STO_CA";
     case ETIR_S_C_STO_RB: return "ETIR_S_C_STO_RB";
     case ETIR_S_C_STO_AB: return "ETIR_S_C_STO_AB";
+    case ETIR_S_C_STO_OFF: return "ETIR_S_C_STO_OFF";
+    case ETIR_S_C_STO_IMM: return "ETIR_S_C_STO_IMM";
+    case ETIR_S_C_STO_IMMR: return "ETIR_S_C_STO_IMMR";
+    case ETIR_S_C_STO_LW: return "ETIR_S_C_STO_LW";
+    case ETIR_S_C_STO_QW: return "ETIR_S_C_STO_QW";
     case ETIR_S_C_STO_GBL_LW: return "ETIR_S_C_STO_GBL_LW";
     case ETIR_S_C_STO_LP_PSB: return "ETIR_S_C_STO_LP_PSB";
     case ETIR_S_C_STO_HINT_GBL: return "ETIR_S_C_STO_HINT_GBL";
     case ETIR_S_C_STO_HINT_PS: return "ETIR_S_C_STO_HINT_PS";
+    case ETIR_S_C_OPR_ADD: return "ETIR_S_C_OPR_ADD";
     case ETIR_S_C_OPR_INSV: return "ETIR_S_C_OPR_INSV";
     case ETIR_S_C_OPR_USH: return "ETIR_S_C_OPR_USH";
     case ETIR_S_C_OPR_ROT: return "ETIR_S_C_OPR_ROT";
@@ -215,34 +335,41 @@ cmd_name (int cmd)
     case ETIR_S_C_STC_BOH_GBL: return "ETIR_S_C_STC_BOH_GBL";
     case ETIR_S_C_STC_BOH_PS: return "ETIR_S_C_STC_BOH_PS";
     case ETIR_S_C_STC_NBH_GBL: return "ETIR_S_C_STC_NBH_GBL";
+    case ETIR_S_C_CTL_SETRB: return "ETIR_S_C_CTL_SETRB";
+    case ETIR_S_C_STC_LP_PSB: return "ETIR_S_C_STC_LP_PSB";
+    case ETIR_S_C_CTL_DFLOC: return "ETIR_S_C_CTL_DFLOC";
+    case ETIR_S_C_CTL_STLOC: return "ETIR_S_C_CTL_STLOC";
+    case ETIR_S_C_CTL_STKDL: return "ETIR_S_C_CTL_STKDL";
 
     default:
       /* These names have not yet been added to this switch statement.  */
-      abort ();
+      (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd);
     }
+
+  return NULL;
 }
 #define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
 
 /* etir_sta
 
-   vms stack commands
+   Vms stack commands.
 
-   handle sta_xxx commands in etir section
-   ptr points to data area in record
+   Handle sta_xxx commands in etir section,
+   ptr points to data area in record.
 
-   see table B-8 of the openVMS linker manual.  */
+   See table B-8 of the openVMS linker manual.  */
 
 static bfd_boolean
-etir_sta (bfd * abfd, int cmd, unsigned char *ptr)
+etir_sta (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
 {
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_sta %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
   switch (cmd)
     {
-      /* stack global
+      /* Stack global
 	 arg: cs	symbol name
 
 	 stack 32 bit value of symbol (high bits set to 0).  */
@@ -265,37 +392,50 @@ etir_sta (bfd * abfd, int cmd, unsigned char *ptr)
 	else
 	  _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1);
       }
+      *quarter_relocs = 1;
       break;
 
-      /* stack longword
+      /* Stack longword
 	 arg: lw	value
 
 	 stack 32 bit value, sign extend to 64 bit.  */
     case ETIR_S_C_STA_LW:
       _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1);
+      /* This one is special as it is both part of the section header
+         and of the ALPHA_R_REFLONG relocation.  */
+      if (bfd_getl16 (ptr - 4 + bfd_getl16 (ptr - 2)) == ETIR_S_C_CTL_DFLOC)
+	*quarter_relocs = 0;
+      else if (*quarter_relocs)
+	*quarter_relocs += 1;
+      else
+	*quarter_relocs = 2;
       break;
 
-      /* stack global
+      /* Stack quadword
 	 arg: qw	value
 
 	 stack 64 bit value of symbol.  */
     case ETIR_S_C_STA_QW:
       _bfd_vms_push (abfd, (uquad) bfd_getl64 (ptr), -1);
+      if (*quarter_relocs)
+	*quarter_relocs += 1;
+      else
+	*quarter_relocs = 2;
       break;
 
-      /* stack psect base plus quadword offset
+      /* Stack psect base plus quadword offset
 	 arg: lw	section index
 	 qw	signed quadword offset (low 32 bits)
 
-	 stack qw argument and section index
+	 Stack qw argument and section index
 	 (see ETIR_S_C_STO_OFF, ETIR_S_C_CTL_SETRB).  */
     case ETIR_S_C_STA_PQ:
       {
 	uquad dummy;
-	unsigned int psect;
+	int psect;
 
 	psect = bfd_getl32 (ptr);
-	if (psect >= PRIV (section_count))
+	if ((unsigned int) psect >= PRIV (section_count))
 	  {
 	    (*_bfd_error_handler) (_("bad section index in %s"),
 				   cmd_name (cmd));
@@ -305,23 +445,31 @@ etir_sta (bfd * abfd, int cmd, unsigned char *ptr)
 	dummy = bfd_getl64 (ptr + 4);
 	_bfd_vms_push (abfd, dummy, (int) psect);
       }
+      /* This one is special as it is both part of the section header
+         and of the ALPHA_R_REFLONG and ALPHA_R_REFQUAD relocations.  */
+      if (bfd_getl16 (ptr - 4 + bfd_getl16 (ptr - 2)) == ETIR_S_C_CTL_SETRB)
+	*quarter_relocs = 0;
+      else
+	*quarter_relocs = 2;
       break;
 
     case ETIR_S_C_STA_LI:
     case ETIR_S_C_STA_MOD:
     case ETIR_S_C_STA_CKARG:
       (*_bfd_error_handler) (_("unsupported STA cmd %s"), cmd_name (cmd));
+      *quarter_relocs = 0;
       return FALSE;
-      break;
 
     default:
       (*_bfd_error_handler) (_("reserved STA cmd %d"), cmd);
+      *quarter_relocs = 0;
       return FALSE;
-      break;
     }
+
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_sta true\n");
 #endif
+
   return TRUE;
 }
 
@@ -335,14 +483,14 @@ etir_sta (bfd * abfd, int cmd, unsigned char *ptr)
    see table B-9 of the openVMS linker manual.  */
 
 static bfd_boolean
-etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
+etir_sto (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
 {
   uquad dummy;
   int psect;
 
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_sto %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
   switch (cmd)
@@ -353,6 +501,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
       dummy = _bfd_vms_pop (abfd, &psect);
       /* FIXME: check top bits.  */
       image_write_b (abfd, (unsigned int) dummy & 0xff);
+      *quarter_relocs = 0;
       break;
 
       /* Store word: pop stack, write word
@@ -361,6 +510,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
       dummy = _bfd_vms_pop (abfd, &psect);
       /* FIXME: check top bits */
       image_write_w (abfd, (unsigned int) dummy & 0xffff);
+      *quarter_relocs = 0;
       break;
 
       /* Store longword: pop stack, write longword
@@ -370,6 +520,10 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
       dummy += (PRIV (sections)[psect])->vma;
       /* FIXME: check top bits.  */
       image_write_l (abfd, (unsigned int) dummy & 0xffffffff);
+      if (*quarter_relocs == 2)
+	*quarter_relocs = 4;
+      else
+	*quarter_relocs += 1;
       break;
 
       /* Store quadword: pop stack, write quadword
@@ -379,6 +533,10 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
       dummy += (PRIV (sections)[psect])->vma;
       /* FIXME: check top bits.  */
       image_write_q (abfd, dummy);
+      if (*quarter_relocs == 2)
+	*quarter_relocs = 4;
+      else
+	*quarter_relocs += 1;
       break;
 
       /* Store immediate repeated: pop stack for repeat count
@@ -393,6 +551,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	while (dummy-- > 0)
 	  image_dump (abfd, ptr+4, size, 0);
       }
+      *quarter_relocs = 0;
       break;
 
       /* Store global: write symbol value
@@ -406,15 +565,13 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
 						      name, FALSE, FALSE);
 	if (entry == NULL)
-	  {
-	    (*_bfd_error_handler) (_("%s: no symbol \"%s\""),
-				   cmd_name (cmd), name);
-	    return FALSE;
-	  }
+	  /* FIXME, reloc.  */
+	  image_write_q (abfd, (uquad) (0));
 	else
 	  /* FIXME, reloc.  */
 	  image_write_q (abfd, (uquad) (entry->symbol->value));
       }
+      *quarter_relocs = 4;
       break;
 
       /* Store code address: write address of entry point
@@ -428,15 +585,13 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
 						      name, FALSE, FALSE);
 	if (entry == NULL)
-	  {
-	    (*_bfd_error_handler) (_("%s: no symbol \"%s\""),
-				   cmd_name (cmd), name);
-	    return FALSE;
-	  }
+	  /* FIXME, reloc.  */
+	  image_write_q (abfd, (uquad) (0));
 	else
 	  /* FIXME, reloc.  */
 	  image_write_q (abfd, (uquad) (entry->symbol->value));
       }
+      *quarter_relocs = 4;
       break;
 
       /* Store offset to psect: pop stack, add low 32 bits to base of psect
@@ -450,6 +605,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	q += (PRIV (sections)[psect1])->vma;
 	image_write_q (abfd, q);
       }
+      *quarter_relocs += 2;
       break;
 
       /* Store immediate
@@ -462,6 +618,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	size = bfd_getl32 (ptr);
 	image_dump (abfd, ptr+4, size, 0);
       }
+      *quarter_relocs = 0;
       break;
 
       /* This code is 'reserved to digital' according to the openVMS
@@ -489,22 +646,26 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	  /* FIXME, reloc.  */
 	  image_write_l (abfd, (unsigned long) (entry->symbol->value));
       }
+      *quarter_relocs = 4;
       break;
 
     case ETIR_S_C_STO_RB:
     case ETIR_S_C_STO_AB:
     case ETIR_S_C_STO_LP_PSB:
       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      break;
+      *quarter_relocs = 0;
+      return FALSE;
 
     case ETIR_S_C_STO_HINT_GBL:
     case ETIR_S_C_STO_HINT_PS:
       (*_bfd_error_handler) (_("%s: not implemented"), cmd_name (cmd));
-      break;
+      *quarter_relocs = 0;
+      return FALSE;
 
     default:
       (*_bfd_error_handler) (_("reserved STO cmd %d"), cmd);
-      break;
+      *quarter_relocs = 0;
+      return FALSE;
     }
 
   return TRUE;
@@ -518,15 +679,22 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
    see table B-10 of the openVMS linker manual.  */
 
 static bfd_boolean
-etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
+etir_opr (bfd *abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED,
+	  int *quarter_relocs)
 {
   long op1, op2;
 
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_opr %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
+  /* No relocation uses OPR commands except ETIR_S_C_OPR_ADD.  */
+  if (cmd == ETIR_S_C_OPR_ADD)
+    *quarter_relocs += 1;
+  else
+    *quarter_relocs = 0;
+
   switch (cmd)
     {
     case ETIR_S_C_OPR_NOP:      /* No-op.  */
@@ -604,7 +772,7 @@ etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
     case ETIR_S_C_OPR_REDEF:     /* Redefine symbol to current location.  */
     case ETIR_S_C_OPR_DFLIT:     /* Define a literal.  */
       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      break;
+      return FALSE;
 
     case ETIR_S_C_OPR_SEL:      /* Select.  */
       if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L)
@@ -619,7 +787,7 @@ etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
 
     default:
       (*_bfd_error_handler) (_("reserved OPR cmd %d"), cmd);
-      break;
+      return FALSE;
     }
 
   return TRUE;
@@ -630,16 +798,19 @@ etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
    See table B-11 of the openVMS linker manual.  */
 
 static bfd_boolean
-etir_ctl (bfd * abfd, int cmd, unsigned char *ptr)
+etir_ctl (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
 {
-  uquad	 dummy;
+  uquad dummy;
   int psect;
 
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_ctl %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
+  /* No relocation uses CTL commands.  */
+  *quarter_relocs = 0;
+
   switch (cmd)
     {
       /* Det relocation base: pop stack, set image location counter
@@ -660,27 +831,28 @@ etir_ctl (bfd * abfd, int cmd, unsigned char *ptr)
 	 arg: none.  */
     case ETIR_S_C_CTL_DFLOC:
       dummy = _bfd_vms_pop (abfd, NULL);
-      /* FIXME */
+      dst_define_location (abfd, dummy);
       break;
 
       /* Set location: pop index, restore location counter from index
 	 arg: none.  */
     case ETIR_S_C_CTL_STLOC:
-      dummy = _bfd_vms_pop (abfd, &psect);
-      /* FIXME */
+      dummy = _bfd_vms_pop (abfd, NULL);
+      dst_restore_location (abfd, dummy);
       break;
 
       /* Stack defined location: pop index, push location counter from index
 	 arg: none.  */
     case ETIR_S_C_CTL_STKDL:
-      dummy = _bfd_vms_pop (abfd, &psect);
-      /* FIXME.  */
+      dummy = _bfd_vms_pop (abfd, NULL);
+      _bfd_vms_push (abfd, dst_retrieve_location (abfd, dummy), -1);
       break;
 
     default:
       (*_bfd_error_handler) (_("reserved CTL cmd %d"), cmd);
-      break;
+      return FALSE;
     }
+
   return TRUE;
 }
 
@@ -689,11 +861,12 @@ etir_ctl (bfd * abfd, int cmd, unsigned char *ptr)
    See table B-12 and B-13 of the openVMS linker manual.  */
 
 static bfd_boolean
-etir_stc (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
+etir_stc (bfd *abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED,
+	  int *quarter_relocs)
 {
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_stc %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
   switch (cmd)
@@ -701,32 +874,17 @@ etir_stc (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
       /* 200 Store-conditional Linkage Pair
 	 arg: none.  */
     case ETIR_S_C_STC_LP:
-      (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      break;
-
-      /* 201 Store-conditional Linkage Pair with Procedure Signature
-	 arg:	lw	linkage index
-		cs	procedure name
-		by	signature length
-		da	signature.  */
-    case ETIR_S_C_STC_LP_PSB:
-      image_inc_ptr (abfd, (uquad) 16);	/* skip entry,procval */
-      break;
 
       /* 202 Store-conditional Address at global address
 	 arg:	lw	linkage index
 		cs	global name.  */
 
     case ETIR_S_C_STC_GBL:
-      (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      break;
 
       /* 203 Store-conditional Code Address at global address
 	 arg:	lw	linkage index
 		cs	procedure name.  */
     case ETIR_S_C_STC_GCA:
-      (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      break;
 
       /* 204 Store-conditional Address at psect + offset
 	 arg:	lw	linkage index
@@ -734,56 +892,82 @@ etir_stc (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
 		qw	offset.  */
     case ETIR_S_C_STC_PS:
       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
+      *quarter_relocs = 0;
+      return FALSE;
+
+      /* 201 Store-conditional Linkage Pair with Procedure Signature
+	 arg:	lw	linkage index
+		cs	procedure name
+		by	signature length
+		da	signature.  */
+
+    case ETIR_S_C_STC_LP_PSB:
+      image_inc_ptr (abfd, (uquad) 16);	/* skip entry,procval */
+      *quarter_relocs = 4;
       break;
 
       /* 205 Store-conditional NOP at address of global
 	 arg: none.  */
     case ETIR_S_C_STC_NOP_GBL:
-
-      /* 206 Store-conditional NOP at pect + offset
-	 arg: none.  */
-    case ETIR_S_C_STC_NOP_PS:
+      /* ALPHA_R_NOP */
 
       /* 207 Store-conditional BSR at global address
 	 arg: none.  */
-    case ETIR_S_C_STC_BSR_GBL:
 
-      /* 208 Store-conditional BSR at pect + offset
-	 arg: none.  */
-    case ETIR_S_C_STC_BSR_PS:
+    case ETIR_S_C_STC_BSR_GBL:
+      /* ALPHA_R_BSR */
 
       /* 209 Store-conditional LDA at global address
 	 arg: none.  */
-    case ETIR_S_C_STC_LDA_GBL:
 
-      /* 210 Store-conditional LDA at psect + offset
-	 arg: none.  */
-    case ETIR_S_C_STC_LDA_PS:
+    case ETIR_S_C_STC_LDA_GBL:
+      /* ALPHA_R_LDA */
 
       /* 211 Store-conditional BSR or Hint at global address
 	 arg: none.  */
-    case ETIR_S_C_STC_BOH_GBL:
 
-      /* 212 Store-conditional BSR or Hint at pect + offset
-	 arg: none.  */
-    case ETIR_S_C_STC_BOH_PS:
+    case ETIR_S_C_STC_BOH_GBL:
+      *quarter_relocs = 4;
+      break;
 
       /* 213 Store-conditional NOP,BSR or HINT at global address
 	 arg: none.  */
+
     case ETIR_S_C_STC_NBH_GBL:
 
-      /* 214 Store-conditional NOP,BSR or HINT at psect + offset
+      /* 206 Store-conditional NOP at pect + offset
+	 arg: none.  */
+
+    case ETIR_S_C_STC_NOP_PS:
+
+      /* 208 Store-conditional BSR at pect + offset
+	 arg: none.  */
+
+    case ETIR_S_C_STC_BSR_PS:
+
+      /* 210 Store-conditional LDA at psect + offset
+	 arg: none.  */
+
+    case ETIR_S_C_STC_LDA_PS:
+
+      /* 212 Store-conditional BSR or Hint at pect + offset
+	 arg: none.  */
+
+    case ETIR_S_C_STC_BOH_PS:
+
+      /* 214 Store-conditional NOP, BSR or HINT at psect + offset
 	 arg: none.  */
     case ETIR_S_C_STC_NBH_PS:
-      /* FIXME */
-      break;
+      (*_bfd_error_handler) ("%s: not supported", cmd_name (cmd));
+      *quarter_relocs = 0;
+      return FALSE;
 
     default:
-#if VMS_DEBUG
-      _bfd_vms_debug (3,  "reserved STC cmd %d", cmd);
-#endif
-      break;
+      (*_bfd_error_handler) (_("reserved STC cmd %d"), cmd);
+      *quarter_relocs = 0;
+      return FALSE;
     }
+
   return TRUE;
 }
 
@@ -851,10 +1035,10 @@ alloc_section (bfd * abfd, unsigned int idx)
 
 /* tir_sta
 
-   vax stack commands
+   Vax stack commands.
 
-   Handle sta_xxx commands in tir section
-   ptr points to data area in record
+   Handle sta_xxx commands in tir section,
+   ptr points to data area in record.
 
    See table 7-3 of the VAX/VMS linker manual.  */
 
@@ -924,7 +1108,7 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 		by	signed byte offset.  */
       {
 	unsigned long dummy;
-	unsigned int psect;
+	int psect;
 
 	if (cmd == TIR_S_C_STA_PB)
 	  psect = *ptr++;
@@ -934,12 +1118,12 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 	    ptr += 2;
 	  }
 
-	if (psect >= PRIV (section_count))
+	if ((unsigned int) psect >= PRIV (section_count))
 	  alloc_section (abfd, psect);
 
 	dummy = (long) *ptr++;
 	dummy += (PRIV (sections)[psect])->vma;
-	_bfd_vms_push (abfd, (uquad) dummy, (int) psect);
+	_bfd_vms_push (abfd, (uquad) dummy, psect);
       }
       break;
 
@@ -951,7 +1135,7 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 		sh	signed short offset.  */
       {
 	unsigned long dummy;
-	unsigned int psect;
+	int psect;
 
 	if (cmd == TIR_S_C_STA_PW)
 	  psect = *ptr++;
@@ -961,12 +1145,12 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 	    ptr += 2;
 	  }
 
-	if (psect >= PRIV (section_count))
+	if ((unsigned int) psect >= PRIV (section_count))
 	  alloc_section (abfd, psect);
 
 	dummy = bfd_getl16 (ptr); ptr+=2;
 	dummy += (PRIV (sections)[psect])->vma;
-	_bfd_vms_push (abfd, (uquad) dummy, (int) psect);
+	_bfd_vms_push (abfd, (uquad) dummy, psect);
       }
       break;
 
@@ -978,7 +1162,7 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 		lw	signed longword offset.	 */
       {
 	unsigned long dummy;
-	unsigned int psect;
+	int psect;
 
 	if (cmd == TIR_S_C_STA_PL)
 	  psect = *ptr++;
@@ -988,12 +1172,12 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 	    ptr += 2;
 	  }
 
-	if (psect >= PRIV (section_count))
+	if ((unsigned int) psect >= PRIV (section_count))
 	  alloc_section (abfd, psect);
 
 	dummy = bfd_getl32 (ptr); ptr += 4;
 	dummy += (PRIV (sections)[psect])->vma;
-	_bfd_vms_push (abfd, (uquad) dummy, (int) psect);
+	_bfd_vms_push (abfd, (uquad) dummy, psect);
       }
       break;
 
@@ -1457,7 +1641,7 @@ static unsigned char *
 tir_ctl (bfd * abfd, unsigned char *ptr)
 {
   unsigned long dummy;
-  unsigned int psect;
+  int psect;
 
 #if VMS_DEBUG
   _bfd_vms_debug (5, "tir_ctl %d\n", *ptr);
@@ -1468,10 +1652,10 @@ tir_ctl (bfd * abfd, unsigned char *ptr)
     case TIR_S_C_CTL_SETRB:
       /* Set relocation base: pop stack, set image location counter
 	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, (int *) &psect);
-      if (psect >= PRIV (section_count))
+      dummy = _bfd_vms_pop (abfd, &psect);
+      if ((unsigned int) psect >= PRIV (section_count))
 	alloc_section (abfd, psect);
-      image_set_ptr (abfd, (int) psect, (uquad) dummy);
+      image_set_ptr (abfd, psect, (uquad) dummy);
       break;
 
     case TIR_S_C_CTL_AUGRB:
@@ -1492,7 +1676,7 @@ tir_ctl (bfd * abfd, unsigned char *ptr)
     case TIR_S_C_CTL_STLOC:
       /* Set location: pop index, restore location counter from index
 	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, (int *) &psect);
+      dummy = _bfd_vms_pop (abfd, &psect);
       (*_bfd_error_handler) (_("%s: not fully implemented"),
 			     tir_cmd_name (ptr[-1]));
       break;
@@ -1500,7 +1684,7 @@ tir_ctl (bfd * abfd, unsigned char *ptr)
     case TIR_S_C_CTL_STKDL:
       /* Stack defined location: pop index, push location counter from index
 	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, (int *) &psect);
+      dummy = _bfd_vms_pop (abfd, &psect);
       (*_bfd_error_handler) (_("%s: not fully implemented"),
 			     tir_cmd_name (ptr[-1]));
       break;
@@ -1517,7 +1701,7 @@ tir_ctl (bfd * abfd, unsigned char *ptr)
 static unsigned char *
 tir_cmd (bfd * abfd, unsigned char *ptr)
 {
-  struct
+  static const struct
   {
     int mincod;
     int maxcod;
@@ -1535,7 +1719,7 @@ tir_cmd (bfd * abfd, unsigned char *ptr)
 
 #if VMS_DEBUG
   _bfd_vms_debug (4, "tir_cmd %d/%x\n", *ptr, *ptr);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
   if (*ptr & 0x80)
@@ -1570,13 +1754,13 @@ tir_cmd (bfd * abfd, unsigned char *ptr)
 /* Handle command from ETIR section.  */
 
 static int
-etir_cmd (bfd * abfd, int cmd, unsigned char *ptr)
+etir_cmd (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
 {
-  static struct
+  static const struct
   {
     int mincod;
     int maxcod;
-    bfd_boolean (*explain) (bfd *, int, unsigned char *);
+    bfd_boolean (*explain) (bfd *, int, unsigned char *, int *);
   }
   etir_table[] =
   {
@@ -1591,8 +1775,8 @@ etir_cmd (bfd * abfd, int cmd, unsigned char *ptr)
   int i = 0;
 
 #if VMS_DEBUG
-  _bfd_vms_debug (4, "etir_cmd %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_vms_debug (4, "etir_cmd: %s(%d)\n", cmd_name (cmd), cmd);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
   while (etir_table[i].mincod >= 0)
@@ -1600,7 +1784,7 @@ etir_cmd (bfd * abfd, int cmd, unsigned char *ptr)
       if ( (etir_table[i].mincod <= cmd)
 	   && (cmd <= etir_table[i].maxcod))
 	{
-	  if (!etir_table[i].explain (abfd, cmd, ptr))
+	  if (!etir_table[i].explain (abfd, cmd, ptr, quarter_relocs))
 	    return -1;
 	  break;
 	}
@@ -1608,7 +1792,7 @@ etir_cmd (bfd * abfd, int cmd, unsigned char *ptr)
     }
 
 #if VMS_DEBUG
-  _bfd_vms_debug (4, "etir_cmd: = 0\n");
+  _bfd_vms_debug (4, "etir_cmd: result = 0\n");
 #endif
   return 0;
 }
@@ -1643,28 +1827,67 @@ analyze_tir (bfd * abfd, unsigned char *ptr, unsigned int length)
 static int
 analyze_etir (bfd * abfd, unsigned char *ptr, unsigned int length)
 {
-  int cmd;
-  unsigned char *maxptr;
+  unsigned char *maxptr = ptr + length;
+  /* Relocations are made of 1, 2 or 4 ETIR commands.
+     We therefore count them using quarters.  */
+  int quarter_relocs = 0;
   int result = 0;
 
 #if VMS_DEBUG
   _bfd_vms_debug (3, "analyze_etir: %d bytes\n", length);
 #endif
 
-  maxptr = ptr + length;
-
   while (ptr < maxptr)
     {
-      cmd = bfd_getl16 (ptr);
-      length = bfd_getl16 (ptr + 2);
-      result = etir_cmd (abfd, cmd, ptr+4);
+      int cmd = bfd_getl16 (ptr);
+      int cmd_length = bfd_getl16 (ptr + 2);
+      result = etir_cmd (abfd, cmd, ptr + 4, &quarter_relocs);
       if (result != 0)
 	break;
-      ptr += length;
+
+      /* If we have a relocation, we record its length to size
+	 future buffers and bump the reloc count of the section.  */
+      if (quarter_relocs)
+	{
+	  vms_section_data (PRIV (image_section))->reloc_size += cmd_length;
+	  abfd->flags |= HAS_RELOC;
+
+	  if (quarter_relocs == 4)
+	    {
+	      PRIV (image_section)->reloc_count++;
+
+#if VMS_DEBUG
+	      _bfd_vms_debug (4, "-> reloc %d at 0x%x\n",
+			      PRIV (image_section)->reloc_count-1,
+			      ptr - (maxptr - length));
+#endif
+
+	      quarter_relocs = 0;
+	    }
+	  else if (quarter_relocs > 4)
+	    {
+
+#if VMS_DEBUG
+	      _bfd_vms_debug (4, "Reloc count error (%d) in section %s\n",
+			      PRIV (image_section)->reloc_count,
+			      PRIV (image_section)->name);
+#endif
+
+	      quarter_relocs = 0;
+	    }
+	}
+
+      /* If we have a Store Immediate, we reserve space for the
+	 count argument.  */
+      else if (cmd == ETIR_S_C_STO_IMM)
+        vms_section_data (PRIV (image_section))->reloc_size
+	  += ETIR_S_C_HEADER_SIZE + 4;
+
+      ptr += cmd_length;
     }
 
 #if VMS_DEBUG
-  _bfd_vms_debug (3, "analyze_etir: = %d\n", result);
+  _bfd_vms_debug (3, "analyze_etir: result = %d\n", result);
 #endif
 
   return result;
@@ -1685,8 +1908,8 @@ _bfd_vms_slurp_tir (bfd * abfd, int objtype)
   switch (objtype)
     {
     case EOBJ_S_C_ETIR:
-      PRIV (vms_rec) += 4;	/* Skip type, size.  */
-      PRIV (rec_size) -= 4;
+      PRIV (vms_rec) += ETIR_S_C_HEADER_SIZE;
+      PRIV (rec_size) -= ETIR_S_C_HEADER_SIZE;
       result = analyze_etir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size));
       break;
     case OBJ_S_C_TIR:
@@ -1702,33 +1925,361 @@ _bfd_vms_slurp_tir (bfd * abfd, int objtype)
   return result;
 }
 
-/* Process EDBG record
-   Return 0 on success, -1 on error
-
-   Not implemented yet.  */
+ /* Slurp relocs from ETIR sections and (temporarily) save them
+    in the per-section reloc buffer.  */
 
 int
-_bfd_vms_slurp_dbg (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
+_bfd_vms_slurp_relocs (bfd *abfd)
 {
+  struct vms_section_data_struct *vsd;
+  unsigned char *begin = PRIV (vms_rec) + 4;
+  unsigned char *end = PRIV (vms_rec) + PRIV (rec_size);
+  unsigned char *ptr;
+  int cmd, length, slurped_length;
+
 #if VMS_DEBUG
-  _bfd_vms_debug (2, "DBG/EDBG\n");
+  _bfd_vms_debug (3, "_bfd_vms_slurp_relocs: %d bytes\n", PRIV (rec_size));
+#endif
+
+  for (ptr = begin; ptr < end; ptr += length)
+    {
+      cmd = bfd_getl16 (ptr);
+      length = bfd_getl16 (ptr + 2);
+      slurped_length = length;
+
+      switch (cmd)
+	{
+	case ETIR_S_C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
+	  /* This one is special as it is both part of the section header
+	     and of the ALPHA_R_REFLONG and ALPHA_R_REFQUAD relocations.  */
+	  if (bfd_getl16 (ptr + length) == ETIR_S_C_CTL_SETRB)
+	    {
+	      int psect = bfd_getl32 (ptr + ETIR_S_C_HEADER_SIZE);
+	      PRIV (image_section) = PRIV (sections)[psect];
+	      continue;
+	    }
+
+	case ETIR_S_C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
+			       /* ALPHA_R_REFQUAD und_section, step 1 */
+	  break;
+
+	case ETIR_S_C_STA_LW: /* ALPHA_R_REFLONG und_section, step 2 */
+			      /* ALPHA_R_REFLONG abs_section, step 1 */
+	  /* This one is special as it is both part of the section header
+	     and of the ALPHA_R_REFLONG relocation.  */
+	  if (bfd_getl16 (ptr + length) == ETIR_S_C_CTL_DFLOC)
+	    {
+	      PRIV (image_section) = PRIV (dst_section);
+	      continue;
+	    }
+
+	case ETIR_S_C_STA_QW: /* ALPHA_R_REFQUAD und_section, step 2 */
+			      /* ALPHA_R_REFQUAD abs_section, step 1 */
+
+	case ETIR_S_C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
+			      /* ALPHA_R_REFLONG abs_section, step 2 */
+			      /* ALPHA_R_REFLONG others, step 2 */
+
+	case ETIR_S_C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
+			      /* ALPHA_R_REFQUAD abs_section, step 2 */
+
+	case ETIR_S_C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
+
+	case ETIR_S_C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
+			       /* ALPHA_R_REFQUAD und_section, step 3 */
+
+	case ETIR_S_C_STO_CA:      /* ALPHA_R_CODEADDR */
+	case ETIR_S_C_STO_GBL:     /* ALPHA_R_REFQUAD und_section */
+	case ETIR_S_C_STO_GBL_LW:  /* ALPHA_R_REFLONG und_section */
+	case ETIR_S_C_STC_LP_PSB:  /* ALPHA_R_LINKAGE */
+	case ETIR_S_C_STC_NOP_GBL: /* ALPHA_R_NOP */
+	case ETIR_S_C_STC_BSR_GBL: /* ALPHA_R_BSR */
+	case ETIR_S_C_STC_LDA_GBL: /* ALPHA_R_LDA */
+	case ETIR_S_C_STC_BOH_GBL: /* ALPHA_R_BOH */
+	  break;
+
+	case ETIR_S_C_STO_IMM:
+	  if (PRIV (image_section)->reloc_count == 0)
+	    continue;
+	  /* This is not a relocation, but we nevertheless slurp the
+	     count argument.  We'll use it to compute the addresses
+	     of the relocations.  */
+	  slurped_length = ETIR_S_C_HEADER_SIZE + 4;
+	  break;
+
+	default:
+	  continue;
+	}
+
+      vsd = vms_section_data (PRIV (image_section));
+      memcpy (vsd->reloc_stream + vsd->reloc_offset, ptr, slurped_length);
+      vsd->reloc_offset += slurped_length;
+      if (vsd->reloc_offset > vsd->reloc_size)
+        {
+	  (*_bfd_error_handler) (_("Reloc size error in section %s"),
+			         PRIV (image_section)->name);
+	  return -1;
+	}
+    }
+
+#if VMS_DEBUG
+  _bfd_vms_debug (3, "_bfd_vms_slurp_relocs: result = 0\n");
 #endif
 
-  abfd->flags |= (HAS_DEBUG | HAS_LINENO);
   return 0;
 }
 
-/* Process ETBT record
-   Return 0 on success, -1 on error
-
-   Not implemented yet.  */
+/* Decode relocs from the reloc buffer of the specified section
+   and internalize them in the specified buffer.  */
 
 int
-_bfd_vms_slurp_tbt (bfd * abfd ATTRIBUTE_UNUSED,
-		    int objtype ATTRIBUTE_UNUSED)
+_bfd_vms_decode_relocs (bfd *abfd, arelent *relocs, asection *section,
+			asymbol **symbols ATTRIBUTE_UNUSED)
 {
+  int saved_cmd, saved_sym_offset, saved_sec_offset, saved_addend_offset;
+  int cmd, sym_offset, sec_offset, address_offset, addend_offset;
+  struct vms_section_data_struct *vsd = vms_section_data (section);
+  bfd_reloc_code_real_type reloc_code;
+  vms_symbol_entry *entry;
+  bfd_vma vaddr = 0;
+  unsigned char *begin = vsd->reloc_stream;
+  unsigned char *end = vsd->reloc_stream + vsd->reloc_size;
+  unsigned char *ptr, *arg_ptr;
+  const char *name;
+  int length;
+
 #if VMS_DEBUG
-  _bfd_vms_debug (2, "TBT/ETBT\n");
+  _bfd_vms_debug (3, "_bfd_vms_decode_relocs: %d bytes\n", vsd->reloc_size);
+#endif
+
+  #define PUSH_CMD()					\
+    {							\
+      saved_cmd = cmd;					\
+      saved_sym_offset = sym_offset - length;		\
+      saved_sec_offset = sec_offset - length;		\
+      saved_addend_offset = addend_offset - length;	\
+      continue;						\
+    }
+
+  #define POP_CMD()					\
+    {							\
+      cmd = saved_cmd;					\
+      saved_cmd = ETIR_S_C_MAXSTCCOD + 1;		\
+      sym_offset = saved_sym_offset;			\
+      sec_offset = saved_sec_offset;			\
+      addend_offset= saved_addend_offset;		\
+    }
+
+  #define CMD_PUSHED (saved_cmd != ETIR_S_C_MAXSTCCOD + 1)
+
+  #define NO_OFFSET -128
+
+  saved_cmd = ETIR_S_C_MAXSTCCOD + 1;
+  saved_sym_offset = NO_OFFSET;
+  saved_sec_offset = NO_OFFSET;
+  saved_addend_offset = NO_OFFSET;
+
+  for (ptr = begin; ptr < end; ptr += length)
+    {
+      cmd = bfd_getl16 (ptr);
+      length = bfd_getl16 (ptr + 2);
+
+      arg_ptr = ptr + ETIR_S_C_HEADER_SIZE;
+      sym_offset = NO_OFFSET;
+      sec_offset = NO_OFFSET;
+      address_offset = NO_OFFSET;
+      addend_offset = NO_OFFSET;
+
+      switch (cmd)
+	{
+	case ETIR_S_C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
+			       /* ALPHA_R_REFQUAD und_section, step 1 */
+	  sym_offset = 0;
+	  PUSH_CMD ()
+
+	case ETIR_S_C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
+	  sec_offset = 0;
+	  addend_offset = 4;
+	  PUSH_CMD ()
+
+	case ETIR_S_C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */
+			      /* ALPHA_R_REFLONG und_section, step 2 */
+	  if (CMD_PUSHED)
+	    {
+	      POP_CMD ()
+	      if (cmd != ETIR_S_C_STA_GBL)
+		{
+		  (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+					 cmd_name (cmd),
+					 cmd_name (ETIR_S_C_STA_LW));
+		  return 0;
+		}
+	      cmd = ETIR_S_C_STA_LW;
+	    }
+	  addend_offset = 0;
+	  PUSH_CMD ()
+
+	case ETIR_S_C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */
+			      /* ALPHA_R_REFQUAD und_section, step 2 */
+	  if (CMD_PUSHED)
+	    {
+	      POP_CMD ()
+	      if (cmd != ETIR_S_C_STA_GBL)
+		{
+		  (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+					 cmd_name (cmd),
+					 cmd_name (ETIR_S_C_STA_QW));
+		  return 0;
+		}
+	      cmd = ETIR_S_C_STA_QW;
+	    }
+	  addend_offset = 0;
+	  PUSH_CMD ()
+
+	case ETIR_S_C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
+			      /* ALPHA_R_REFLONG abs_section, step 2 */
+			      /* ALPHA_R_REFLONG others, step 2 */
+	  POP_CMD ()
+	  if (cmd != ETIR_S_C_OPR_ADD
+	      && cmd != ETIR_S_C_STA_LW
+	      && cmd != ETIR_S_C_STA_PQ)
+	    {
+	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+	        cmd_name (cmd), cmd_name (ETIR_S_C_STO_LW));
+	      return 0;
+	    }
+	  reloc_code = BFD_RELOC_32;
+	  break;
+
+	case ETIR_S_C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
+			      /* ALPHA_R_REFQUAD abs_section, step 2 */
+	  POP_CMD ()
+	  if (cmd != ETIR_S_C_OPR_ADD && cmd != ETIR_S_C_STA_QW)
+	    {
+	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+	        cmd_name (cmd), cmd_name (ETIR_S_C_STO_QW));
+	      return 0;
+	    }
+	  reloc_code = BFD_RELOC_64;
+	  break;
+
+	case ETIR_S_C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
+	  POP_CMD ()
+	  if (cmd != ETIR_S_C_STA_PQ)
+	    {
+	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+	        cmd_name (cmd), cmd_name (ETIR_S_C_STO_OFF));
+	      return 0;
+	    }
+	  reloc_code = BFD_RELOC_64;
+	  break;
+
+	case ETIR_S_C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
+			       /* ALPHA_R_REFQUAD und_section, step 3 */
+	  POP_CMD ()
+	  if (cmd != ETIR_S_C_STA_LW && cmd != ETIR_S_C_STA_QW)
+	    {
+	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+	        cmd_name (cmd), cmd_name (ETIR_S_C_OPR_ADD));
+	      return 0;
+	    }
+	  cmd = ETIR_S_C_OPR_ADD;
+	  PUSH_CMD ()
+
+	case ETIR_S_C_STO_CA: /* ALPHA_R_CODEADDR */
+	  reloc_code = BFD_RELOC_ALPHA_CODEADDR;
+	  sym_offset = 0;
+	  break;
+
+	case ETIR_S_C_STO_GBL: /* ALPHA_R_REFQUAD und_section */
+	  reloc_code = BFD_RELOC_64;
+	  sym_offset = 0;
+	  break;
+
+	case ETIR_S_C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */
+	  reloc_code = BFD_RELOC_32;
+	  sym_offset = 0;
+	  break;
+
+	case ETIR_S_C_STC_LP_PSB: /* ALPHA_R_LINKAGE */
+	  reloc_code = BFD_RELOC_ALPHA_LINKAGE;
+	  sym_offset = 4;
+	  break;
+
+	case ETIR_S_C_STC_NOP_GBL: /* ALPHA_R_NOP */
+	  reloc_code = BFD_RELOC_ALPHA_NOP;
+	  goto call_reloc;
+
+	case ETIR_S_C_STC_BSR_GBL: /* ALPHA_R_BSR */
+	  reloc_code = BFD_RELOC_ALPHA_BSR;
+	  goto call_reloc;
+
+	case ETIR_S_C_STC_LDA_GBL: /* ALPHA_R_LDA */
+	  reloc_code = BFD_RELOC_ALPHA_LDA;
+	  goto call_reloc;
+
+	case ETIR_S_C_STC_BOH_GBL: /* ALPHA_R_BOH */
+	  reloc_code = BFD_RELOC_ALPHA_BOH;
+	  goto call_reloc;
+
+	call_reloc:
+	  sym_offset = 32;
+	  address_offset = 8;
+	  addend_offset = 24;
+	  break;
+
+	case ETIR_S_C_STO_IMM:
+	  vaddr += bfd_getl32 (arg_ptr);
+	  length = ETIR_S_C_HEADER_SIZE + 4;
+	  continue;
+
+	default:
+	  continue;
+	}
+
+      relocs->howto = bfd_reloc_type_lookup (abfd, reloc_code);
+
+      if (sym_offset > NO_OFFSET)
+	{
+	  name = _bfd_vms_save_counted_string (arg_ptr + sym_offset);
+	  entry = (vms_symbol_entry *)
+	    bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
+	  if (entry == NULL)
+	    {
+	      (*_bfd_error_handler) (_("Unknown symbol %s in command %s"),
+				     name, cmd_name (cmd));
+	      relocs->sym_ptr_ptr = NULL;
+	    }
+	  else
+	    /* ??? This is a hack.  We should point in 'symbols'.  */
+	    relocs->sym_ptr_ptr = &entry->symbol;
+	}
+      else if (sec_offset > NO_OFFSET)
+	relocs->sym_ptr_ptr
+	  = PRIV (sections)[bfd_getl32 (arg_ptr + sec_offset)]->symbol_ptr_ptr;
+      else
+	relocs->sym_ptr_ptr = NULL;
+
+      if (address_offset > NO_OFFSET)
+	relocs->address = bfd_getl64 (arg_ptr + address_offset);
+      else
+	relocs->address = vaddr;
+
+      if (addend_offset > NO_OFFSET)
+	relocs->addend = bfd_getl64 (arg_ptr + addend_offset);
+      else
+	relocs->addend = 0;
+
+      vaddr += bfd_get_reloc_size (relocs->howto);
+      relocs++;     
+    }
+
+  #undef PUSH_CMD
+  #undef POP_CMD
+  #undef NO_OFFSET
+
+#if VMS_DEBUG
+  _bfd_vms_debug (3, "_bfd_vms_decode_relocs: result = 0\n");
 #endif
 
   return 0;
@@ -1750,6 +2301,20 @@ _bfd_vms_slurp_lnk (bfd * abfd ATTRIBUTE_UNUSED,
   return 0;
 }
 
+/* WRITE ETIR SECTION
+
+   This is still under construction and therefore not documented.  */
+
+static void start_etir_record (bfd *abfd, int index, uquad offset,
+			       bfd_boolean justoffset);
+static void start_first_etbt_record (bfd *abfd);
+static void start_another_etbt_record (bfd *abfd);
+static void sto_imm (bfd *abfd, bfd_size_type, unsigned char *, bfd_vma vaddr,
+		     int index, const char *name);
+static void end_etir_record (bfd *abfd);
+static void etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr,
+			       int checklen);
+
 /* Start ETIR record for section #index at virtual addr offset.  */
 
 static void
@@ -1780,25 +2345,20 @@ end_etir_record (bfd * abfd)
   _bfd_vms_output_end (abfd);
 }
 
-/* WRITE ETIR SECTION
-
-   This is still under construction and therefore not documented.  */
+/* Output a STO_IMM command for SSIZE bytes of data from CPR at virtual
+   address VADDR in section specified by INDEX and NAME.  */
 
 static void
-sto_imm (bfd * abfd, vms_section *sptr, bfd_vma vaddr, int index)
+sto_imm (bfd *abfd, bfd_size_type ssize, unsigned char *cptr, bfd_vma vaddr,
+	 int index, const char *name)
 {
-  int size;
-  int ssize;
-  unsigned char *cptr;
+  bfd_size_type size;
 
 #if VMS_DEBUG
-  _bfd_vms_debug (8, "sto_imm %d bytes\n", sptr->size);
-  _bfd_hexdump (9, sptr->contents, (int) sptr->size, (int) vaddr);
+  _bfd_vms_debug (8, "sto_imm %d bytes\n", ssize);
+  _bfd_hexdump (9, cptr, (int) ssize, (int) vaddr);
 #endif
 
-  ssize = sptr->size;
-  cptr = sptr->contents;
-
   while (ssize > 0)
     {
       /* Try all the rest.  */
@@ -1808,11 +2368,14 @@ sto_imm (bfd * abfd, vms_section *sptr, bfd_vma vaddr, int index)
 	{
 	  /* Doesn't fit, split !  */
 	  end_etir_record (abfd);
-	  start_etir_record (abfd, index, vaddr, FALSE);
-	  /* Get max size.  */
-	  size = _bfd_vms_output_check (abfd, 0);
-	  /* More than what's left ?  */
-	  if (size > ssize)
+
+	  if (name [0] && name[1] == 'v' && !strcmp (name, ".vmsdebug"))
+	    start_another_etbt_record (abfd);
+	  else
+	    start_etir_record (abfd, index, vaddr, FALSE);
+
+	  size = _bfd_vms_output_check (abfd, 0);	/* get max size */
+	  if (size > ssize)			/* more than what's left ? */
 	    size = ssize;
 	}
 
@@ -1827,8 +2390,63 @@ sto_imm (bfd * abfd, vms_section *sptr, bfd_vma vaddr, int index)
 #endif
 
       vaddr += size;
-      ssize -= size;
       cptr += size;
+      ssize -= size;
+    }
+}
+
+/* Start ETBT record for section #index at virtual addr offset.  */
+
+static void
+start_first_etbt_record (bfd *abfd)
+{
+  _bfd_vms_output_begin (abfd, EOBJ_S_C_ETBT, -1);
+  _bfd_vms_output_push (abfd);
+
+  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1);	/* push start offset */
+  _bfd_vms_output_long (abfd, (unsigned long) 0);
+  _bfd_vms_output_flush (abfd);
+
+  _bfd_vms_output_begin (abfd, ETIR_S_C_CTL_DFLOC, -1);	/* start = pop() */
+  _bfd_vms_output_flush (abfd);
+}
+
+static void
+start_another_etbt_record (bfd *abfd)
+{
+  _bfd_vms_output_begin (abfd, EOBJ_S_C_ETBT, -1);
+  _bfd_vms_output_push (abfd);
+}
+
+static void
+etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, int checklen)
+{
+  if (_bfd_vms_output_check (abfd, checklen) < 0)
+    {
+      end_etir_record (abfd);
+      if (section->name[0] && section->name[1] == 'v'
+	  && !strcmp (section->name, ".vmsdebug"))
+	start_another_etbt_record (abfd);
+      else
+	start_etir_record (abfd, section->index, vaddr, FALSE);
+    }
+}
+
+/* Return whether RELOC must be deferred till the end.  */
+
+static int
+defer_reloc_p (arelent *reloc)
+{
+  switch (reloc->howto->type)
+    {
+    case ALPHA_R_NOP:
+    case ALPHA_R_LDA:
+    case ALPHA_R_BSR:
+    case ALPHA_R_BOH:
+      return 1;
+
+    default:
+      return 0;
     }
 }
 
@@ -1838,8 +2456,6 @@ int
 _bfd_vms_write_tir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
 {
   asection *section;
-  vms_section *sptr;
-  int nextoffset;
 
 #if VMS_DEBUG
   _bfd_vms_debug (2, "vms_write_tir (%p, %d)\n", abfd, objtype);
@@ -1847,391 +2463,346 @@ _bfd_vms_write_tir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
 
   _bfd_vms_output_alignment (abfd, 4);
 
-  nextoffset = 0;
   PRIV (vms_linkage_index) = 1;
 
-  /* Dump all other sections.  */
-  section = abfd->sections;
-
-  while (section != NULL)
+  for (section = abfd->sections; section; section = section->next)
     {
-
 #if VMS_DEBUG
       _bfd_vms_debug (4, "writing %d. section '%s' (%d bytes)\n",
 		      section->index, section->name,
 		      (int) (section->size));
 #endif
 
+      if (!(section->flags & SEC_HAS_CONTENTS)
+	  || bfd_is_com_section (section))
+	continue;
+
+      if (!section->contents)
+	{
+	  bfd_set_error (bfd_error_no_contents);
+	  return -1;
+	}
+
+      if (section->name[0]
+	  && section->name[1] == 'v'
+	  && !strcmp (section->name, ".vmsdebug"))
+	start_first_etbt_record (abfd);
+      else
+	start_etir_record (abfd, section->index, 0, FALSE);
+
       if (section->flags & SEC_RELOC)
 	{
-	  int i;
+	  bfd_vma curr_addr = 0;
+	  unsigned char *curr_data = section->contents;
+	  bfd_size_type size;
+	  int pass2_needed = 0;
+	  int pass2_in_progress = 0;
+	  unsigned int irel;
+
+	  if (section->reloc_count <= 0)
+	    (*_bfd_error_handler)
+	      (_("SEC_RELOC with no relocs in section %s"), section->name);
 
-	  if ((i = section->reloc_count) <= 0)
-	    (*_bfd_error_handler) (_("SEC_RELOC with no relocs in section %s"),
-				   section->name);
 #if VMS_DEBUG
 	  else
 	    {
-	      arelent **rptr;
+	      int i = section->reloc_count;
+	      arelent **rptr = section->orelocation;
 	      _bfd_vms_debug (4, "%d relocations:\n", i);
-	      rptr = section->orelocation;
 	      while (i-- > 0)
 		{
-		  _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, addr %08lx, off %08lx, len %d: %s\n",
+		  _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, "
+				     "addr %08lx, off %08lx, len %d: %s\n",
 				  (*(*rptr)->sym_ptr_ptr)->name,
 				  (*(*rptr)->sym_ptr_ptr)->section->name,
 				  (long) (*(*rptr)->sym_ptr_ptr)->value,
 				  (*rptr)->address, (*rptr)->addend,
 				  bfd_get_reloc_size ((*rptr)->howto),
-				  (*rptr)->howto->name);
+				   ( *rptr)->howto->name);
 		  rptr++;
 		}
 	    }
 #endif
-	}
 
-      if ((section->flags & SEC_HAS_CONTENTS)
-	  && (! bfd_is_com_section (section)))
-	{
-	  /* Virtual addr in section.  */
-	  bfd_vma vaddr;
-
-	  sptr = _bfd_get_vms_section (abfd, section->index);
-	  if (sptr == NULL)
+	new_pass:
+	  for (irel = 0; irel < section->reloc_count; irel++)
 	    {
-	      bfd_set_error (bfd_error_no_contents);
-	      return -1;
-	    }
+	      struct evax_private_udata_struct *udata;
+	      arelent *rptr = section->orelocation [irel];
+	      bfd_vma addr = rptr->address;
+	      asymbol *sym = *rptr->sym_ptr_ptr;
+	      asection *sec = sym->section;
+	      int defer = defer_reloc_p (rptr);
+	      unsigned int slen;
+	      char *hash;
+
+	      if (pass2_in_progress)
+		{
+		  /* Non-deferred relocs have already been output.  */
+		  if (!defer)
+		    continue;
+		}
+	      else
+		{
+		  /* Deferred relocs must be output at the very end.  */
+		  if (defer)
+		    {
+		      pass2_needed = 1;
+		      continue;
+		    }
 
-	  vaddr = (bfd_vma) (sptr->offset);
+		  /* Regular relocs are intertwined with binary data.  */
+	          if (curr_addr > addr)
+		    (*_bfd_error_handler) (_("Size error in section %s"),
+					   section->name);
+		  size = addr - curr_addr;
+		  sto_imm (abfd, size, curr_data, curr_addr,
+		          section->index, section->name);
+		  curr_data += size;
+		  curr_addr += size;
+		}
 
-	  start_etir_record (abfd, section->index, (uquad) sptr->offset,
-			     FALSE);
+	      size = bfd_get_reloc_size (rptr->howto);
 
-	  while (sptr != NULL)
-	    {
-	      /* One STA_PQ, CTL_SETRB per vms_section.  */
-	      if (section->flags & SEC_RELOC)
-		{
-		  /* Check for relocs.  */
-		  arelent **rptr = section->orelocation;
-		  int i = section->reloc_count;
+	      switch (rptr->howto->type)
+	        {
+		case ALPHA_R_IGNORE:
+		  break;
 
-		  for (;;)
+		case ALPHA_R_REFLONG:
+		  if (bfd_is_und_section (sym->section))
 		    {
-		      bfd_size_type addr = (*rptr)->address;
-		      bfd_size_type len = bfd_get_reloc_size ((*rptr)->howto);
-		      if (sptr->offset < addr)
-			{
-			  /* Sptr starts before reloc.  */
-			  bfd_size_type before = addr - sptr->offset;
-			  if (sptr->size <= before)
-			    {
-			      /* Complete before.  */
-			      sto_imm (abfd, sptr, vaddr, section->index);
-			      vaddr += sptr->size;
-			      break;
-			    }
-			  else
-			    {
-			      /* Partly before.  */
-			      int after = sptr->size - before;
-
-			      sptr->size = before;
-			      sto_imm (abfd, sptr, vaddr, section->index);
-			      vaddr += sptr->size;
-			      sptr->contents += before;
-			      sptr->offset += before;
-			      sptr->size = after;
-			    }
-			}
-		      else if (sptr->offset == addr)
+		      bfd_vma addend = rptr->addend;
+		      slen = strlen ((char *) sym->name);
+		      hash = _bfd_vms_length_hash_symbol
+			       (abfd, sym->name, EOBJ_S_C_SYMSIZ);
+		      etir_output_check (abfd, section, curr_addr, slen);
+		      if (addend)
 			{
-			  /* Sptr starts at reloc.  */
-			  asymbol *sym = *(*rptr)->sym_ptr_ptr;
-			  asection *sec = sym->section;
-
-			  switch ((*rptr)->howto->type)
-			    {
-			    case ALPHA_R_IGNORE:
-			      break;
-
-			    case ALPHA_R_REFLONG:
-			      {
-				if (bfd_is_und_section (sym->section))
-				  {
-				    int slen = strlen ((char *) sym->name);
-				    char *hash;
-
-				    if (_bfd_vms_output_check (abfd, slen) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_GBL_LW,
-							   -1);
-				    hash = (_bfd_vms_length_hash_symbol
-					    (abfd, sym->name, EOBJ_S_C_SYMSIZ));
-				    _bfd_vms_output_counted (abfd, hash);
-				    _bfd_vms_output_flush (abfd);
-				  }
-				else if (bfd_is_abs_section (sym->section))
-				  {
-				    if (_bfd_vms_output_check (abfd, 16) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STA_LW,
-							   -1);
-				    _bfd_vms_output_quad (abfd,
-							  (uquad) sym->value);
-				    _bfd_vms_output_flush (abfd);
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_LW,
-							   -1);
-				    _bfd_vms_output_flush (abfd);
-				  }
-				else
-				  {
-				    if (_bfd_vms_output_check (abfd, 32) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STA_PQ,
-							   -1);
-				    _bfd_vms_output_long (abfd,
-							  (unsigned long) (sec->index));
-				    _bfd_vms_output_quad (abfd,
-							  ((uquad) (*rptr)->addend
-							   + (uquad) sym->value));
-				    _bfd_vms_output_flush (abfd);
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_LW,
-							   -1);
-				    _bfd_vms_output_flush (abfd);
-				  }
-			      }
-			      break;
-
-			    case ALPHA_R_REFQUAD:
-			      {
-				if (bfd_is_und_section (sym->section))
-				  {
-				    int slen = strlen ((char *) sym->name);
-				    char *hash;
-
-				    if (_bfd_vms_output_check (abfd, slen) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_GBL,
-							   -1);
-				    hash = (_bfd_vms_length_hash_symbol
-					    (abfd, sym->name, EOBJ_S_C_SYMSIZ));
-				    _bfd_vms_output_counted (abfd, hash);
-				    _bfd_vms_output_flush (abfd);
-				  }
-				else if (bfd_is_abs_section (sym->section))
-				  {
-				    if (_bfd_vms_output_check (abfd, 16) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STA_QW,
-							   -1);
-				    _bfd_vms_output_quad (abfd,
-							  (uquad) sym->value);
-				    _bfd_vms_output_flush (abfd);
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_QW,
-							   -1);
-				    _bfd_vms_output_flush (abfd);
-				  }
-				else
-				  {
-				    if (_bfd_vms_output_check (abfd, 32) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STA_PQ,
-							   -1);
-				    _bfd_vms_output_long (abfd,
-							  (unsigned long) (sec->index));
-				    _bfd_vms_output_quad (abfd,
-							  ((uquad) (*rptr)->addend
-							   + (uquad) sym->value));
-				    _bfd_vms_output_flush (abfd);
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_OFF,
-							   -1);
-				    _bfd_vms_output_flush (abfd);
-				  }
-			      }
-			      break;
-
-			    case ALPHA_R_HINT:
-			      {
-				int hint_size;
-				char *hash ATTRIBUTE_UNUSED;
-
-				hint_size = sptr->size;
-				sptr->size = len;
-				sto_imm (abfd, sptr, vaddr, section->index);
-				sptr->size = hint_size;
-			      }
-			      break;
-			    case ALPHA_R_LINKAGE:
-			      {
-				char *hash;
-
-				if (_bfd_vms_output_check (abfd, 64) < 0)
-				  {
-				    end_etir_record (abfd);
-				    start_etir_record (abfd, section->index,
-						       vaddr, FALSE);
-				  }
-				_bfd_vms_output_begin (abfd,
-						       ETIR_S_C_STC_LP_PSB,
-						       -1);
-				_bfd_vms_output_long (abfd,
-						      (unsigned long) PRIV (vms_linkage_index));
-				PRIV (vms_linkage_index) += 2;
-				hash = (_bfd_vms_length_hash_symbol
-					(abfd, sym->name, EOBJ_S_C_SYMSIZ));
-				_bfd_vms_output_counted (abfd, hash);
-				_bfd_vms_output_byte (abfd, 0);
-				_bfd_vms_output_flush (abfd);
-			      }
-			      break;
-
-			    case ALPHA_R_CODEADDR:
-			      {
-				int slen = strlen ((char *) sym->name);
-				char *hash;
-				if (_bfd_vms_output_check (abfd, slen) < 0)
-				  {
-				    end_etir_record (abfd);
-				    start_etir_record (abfd,
-						       section->index,
-						       vaddr, FALSE);
-				  }
-				_bfd_vms_output_begin (abfd,
-						       ETIR_S_C_STO_CA,
-						       -1);
-				hash = (_bfd_vms_length_hash_symbol
-					(abfd, sym->name, EOBJ_S_C_SYMSIZ));
-				_bfd_vms_output_counted (abfd, hash);
-				_bfd_vms_output_flush (abfd);
-			      }
-			      break;
-
-			    default:
-			      (*_bfd_error_handler) (_("Unhandled relocation %s"),
-						     (*rptr)->howto->name);
-			      break;
-			    }
-
-			  vaddr += len;
-
-			  if (len == sptr->size)
-			    {
-			      break;
-			    }
-			  else
-			    {
-			      sptr->contents += len;
-			      sptr->offset += len;
-			      sptr->size -= len;
-			      i--;
-			      rptr++;
-			    }
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_GBL, -1);
+			  _bfd_vms_output_counted (abfd, hash);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1);
+			  _bfd_vms_output_long (abfd, (unsigned long) addend);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_OPR_ADD, -1);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1);
+			  _bfd_vms_output_flush (abfd);
 			}
 		      else
 			{
-			  /* Sptr starts after reloc.  */
-			  i--;
-			  /* Check next reloc.  */
-			  rptr++;
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_GBL_LW, -1);
+			  _bfd_vms_output_counted (abfd, hash);
+			  _bfd_vms_output_flush (abfd);
 			}
+		    }
+		  else if (bfd_is_abs_section (sym->section))
+		    {
+		      etir_output_check (abfd, section, curr_addr, 16);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1);
+		      _bfd_vms_output_long (abfd, (unsigned long) sym->value);
+		      _bfd_vms_output_flush (abfd);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1);
+		      _bfd_vms_output_flush (abfd);
+		    }
+		  else
+		    {
+		      etir_output_check (abfd, section, curr_addr, 32);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1);
+		      _bfd_vms_output_long (abfd, (unsigned long) sec->index);
+		      _bfd_vms_output_quad (abfd, (uquad) rptr->addend
+						    + (uquad) sym->value);
+		      _bfd_vms_output_flush (abfd);
+		      /* ??? Table B-8 of the OpenVMS Linker Utilily Manual
+			 says that we should have a ETIR_S_C_STO_OFF here.
+			 But the relocation would not be BFD_RELOC_32 then.
+			 This case is very likely unreachable.  */
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1);
+		      _bfd_vms_output_flush (abfd);
+		    }
+		  break;
 
-		      if (i == 0)
+		case ALPHA_R_REFQUAD:
+		  if (bfd_is_und_section (sym->section))
+		    {
+		      bfd_vma addend = rptr->addend;
+		      slen = strlen ((char *) sym->name);
+		      hash = _bfd_vms_length_hash_symbol
+			       (abfd, sym->name, EOBJ_S_C_SYMSIZ);
+		      etir_output_check (abfd, section, curr_addr, slen);
+		      if (addend)
+			{
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_GBL, -1);
+			  _bfd_vms_output_counted (abfd, hash);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_QW, -1);
+			  _bfd_vms_output_quad (abfd, (uquad) addend);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_OPR_ADD, -1);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_QW, -1);
+			  _bfd_vms_output_flush (abfd);
+			}
+		      else
 			{
-			  /* All reloc checked.  */
-			  if (sptr->size > 0)
-			    {
-			      /* Dump rest.  */
-			      sto_imm (abfd, sptr, vaddr, section->index);
-			      vaddr += sptr->size;
-			    }
-			  break;
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_GBL, -1);
+			  _bfd_vms_output_counted (abfd, hash);
+			  _bfd_vms_output_flush (abfd);
 			}
 		    }
+		  else if (bfd_is_abs_section (sym->section))
+		    {
+		      etir_output_check (abfd, section, curr_addr, 16);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_QW, -1);
+		      _bfd_vms_output_quad (abfd, (uquad) sym->value);
+		      _bfd_vms_output_flush (abfd);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_QW, -1);
+		      _bfd_vms_output_flush (abfd);
+		    }
+		  else
+		    {
+		      etir_output_check (abfd, section, curr_addr, 32);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1);
+		      _bfd_vms_output_long (abfd, (unsigned long) sec->index);
+		      _bfd_vms_output_quad (abfd, (uquad) rptr->addend
+						    + (uquad) sym->value);
+		      _bfd_vms_output_flush (abfd);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_OFF, -1);
+		      _bfd_vms_output_flush (abfd);
+		    }
+		  break;
+
+		case ALPHA_R_HINT:
+		  sto_imm (abfd, size, curr_data, curr_addr,
+			   section->index, section->name);
+		  break;
+		
+		case ALPHA_R_LINKAGE:
+		  etir_output_check (abfd, section, curr_addr, 64);
+		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_LP_PSB, -1);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) PRIV (vms_linkage_index));
+		  PRIV (vms_linkage_index) += 2;
+		  hash = _bfd_vms_length_hash_symbol
+			   (abfd, sym->name, EOBJ_S_C_SYMSIZ);
+		  _bfd_vms_output_counted (abfd, hash);
+		  _bfd_vms_output_byte (abfd, 0);
+		  _bfd_vms_output_flush (abfd);
+		  break;
+
+		case ALPHA_R_CODEADDR:
+		  slen = strlen ((char *) sym->name);
+		  hash = _bfd_vms_length_hash_symbol
+			   (abfd, sym->name, EOBJ_S_C_SYMSIZ);
+		  etir_output_check (abfd, section, curr_addr, slen);
+		  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_CA, -1);
+		  _bfd_vms_output_counted (abfd, hash);
+		  _bfd_vms_output_flush (abfd);
+		  break;
+
+		case ALPHA_R_NOP:
+		  udata
+		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
+		  etir_output_check (abfd, section, curr_addr,
+				     32 + 1 + strlen (udata->origname));
+		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_NOP_GBL, -1);
+		  _bfd_vms_output_long (abfd, (unsigned long) udata->lkindex);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->address);
+		  _bfd_vms_output_long (abfd, (unsigned long) 0x47ff041f);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->addend);
+		  _bfd_vms_output_counted
+		    (abfd, _bfd_vms_length_hash_symbol
+			     (abfd, udata->origname, EOBJ_S_C_SYMSIZ));
+		  _bfd_vms_output_flush (abfd);
+		  break;
+
+		case ALPHA_R_BSR:
+		  (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
+		  break;
+
+		case ALPHA_R_LDA:
+		  udata
+		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
+		  etir_output_check (abfd, section, curr_addr,
+				     32 + 1 + strlen (udata->origname));
+		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_LDA_GBL, -1);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->lkindex + 1);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->address);
+		  _bfd_vms_output_long (abfd, (unsigned long) 0x237B0000);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->bsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->addend);
+		  _bfd_vms_output_counted
+		    (abfd, _bfd_vms_length_hash_symbol
+			    (abfd, udata->origname, EOBJ_S_C_SYMSIZ));
+		  _bfd_vms_output_flush (abfd);
+		  break;
+
+		case ALPHA_R_BOH:
+		  udata
+		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
+		  etir_output_check (abfd, section, curr_addr,
+				       32 + 1 + strlen (udata->origname));
+		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_BOH_GBL, -1);
+		  _bfd_vms_output_long (abfd, (unsigned long) udata->lkindex);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->address);
+		  _bfd_vms_output_long (abfd, (unsigned long) 0xD3400000);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->addend);
+		  _bfd_vms_output_counted
+		    (abfd, _bfd_vms_length_hash_symbol
+			     (abfd, udata->origname, EOBJ_S_C_SYMSIZ));
+		  _bfd_vms_output_flush (abfd);
+		  break;
+
+		default:
+		  (*_bfd_error_handler) (_("Unhandled relocation %s"),
+		  			 rptr->howto->name);
+		  break;
 		}
-	      else
+
+	      curr_data += size;
+	      curr_addr += size;
+	    } /* End of relocs loop.  */
+
+	  if (!pass2_in_progress)
+	    {
+	      /* Output rest of section.  */
+	      if (curr_addr > section->size)
+		(*_bfd_error_handler) (_("Size error in section %s"),
+				       section->name);
+	      size = section->size - curr_addr;
+	      sto_imm (abfd, size, curr_data, curr_addr,
+		       section->index, section->name);
+	      curr_data += size;
+	      curr_addr += size;
+
+	      if (pass2_needed)
 		{
-		  /* No relocs, just dump.  */
-		  sto_imm (abfd, sptr, vaddr, section->index);
-		  vaddr += sptr->size;
+		  pass2_in_progress = 1;
+		  goto new_pass;
 		}
-
-	      sptr = sptr->next;
 	    }
-
-	  end_etir_record (abfd);
 	}
+  
+      else /* (section->flags & SEC_RELOC) */
+	sto_imm (abfd, section->size, section->contents, 0,
+		 section->index, section->name);
 
-      section = section->next;
+      end_etir_record (abfd);
     }
 
   _bfd_vms_output_alignment (abfd, 2);
   return 0;
 }
-
-/* Write traceback data for bfd abfd.  */
-
-int
-_bfd_vms_write_tbt (bfd * abfd ATTRIBUTE_UNUSED,
-		    int objtype ATTRIBUTE_UNUSED)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype);
-#endif
-
-  return 0;
-}
-
-/* Write debug info for bfd abfd.  */
-
-int
-_bfd_vms_write_dbg (bfd * abfd ATTRIBUTE_UNUSED,
-		    int objtype ATTRIBUTE_UNUSED)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (2, "vms_write_dbg (%p, objtype)\n", abfd, objtype);
-#endif
-
-  return 0;
-}
diff --git a/bfd/vms.c b/bfd/vms.c
index 1944c1e..8111d49 100644
--- a/bfd/vms.c
+++ b/bfd/vms.c
@@ -1,7 +1,9 @@
 /* vms.c -- BFD back-end for VAX (openVMS/VAX) and
    EVAX (openVMS/Alpha) files.
    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-   2006, 2007, 2008 Free Software Foundation, Inc.
+   2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+
+   Main file.
 
    Written by Klaus K"ampf (kkaempf@rmi.de)
 
@@ -20,6 +22,13 @@
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
    MA 02110-1301, USA.  */
 
+#ifdef VMS
+#include <rms.h>
+#include <starlet.h>
+#define RME$C_SETRFM 0x00000001
+#include <unistd.h>
+#endif
+
 #include "sysdep.h"
 #include "bfd.h"
 #include "bfdlink.h"
@@ -27,6 +36,108 @@
 
 #include "vms.h"
 
+static bfd_boolean vms_initialize (bfd *);
+static bfd_boolean fill_section_ptr (struct bfd_hash_entry *, PTR);
+static bfd_boolean vms_fixup_sections (bfd *);
+static bfd_boolean copy_symbols (struct bfd_hash_entry *, PTR);
+static bfd_reloc_status_type reloc_nil (bfd *, arelent *, asymbol *, PTR,
+					asection *, bfd *, char **);
+static int vms_slurp_module (bfd *abfd);
+static int vms_slurp_image (bfd *abfd);
+static const struct bfd_target *vms_object_p (bfd *abfd);
+static const struct bfd_target *vms_archive_p (bfd *abfd);
+static bfd_boolean vms_mkobject (bfd *abfd);
+static bfd_boolean vms_write_object_contents (bfd *abfd);
+static void free_reloc_stream (bfd *abfd, asection *section, void *data);
+static bfd_boolean vms_close_and_cleanup (bfd *abfd);
+static bfd_boolean vms_bfd_free_cached_info (bfd *abfd);
+static bfd_boolean vms_new_section_hook (bfd *abfd, asection *section);
+static bfd_boolean vms_get_section_contents
+  (bfd *abfd, asection *section, PTR x1, file_ptr x2, bfd_size_type x3);
+static bfd_boolean vms_get_section_contents_in_window
+  (bfd *abfd, asection *section, bfd_window *w, file_ptr offset,
+   bfd_size_type count);
+static bfd_boolean vms_bfd_copy_private_bfd_data (bfd *src, bfd *dest);
+static bfd_boolean vms_bfd_copy_private_section_data
+  (bfd *srcbfd, asection *srcsec, bfd *dstbfd, asection *dstsec);
+static bfd_boolean vms_bfd_copy_private_symbol_data
+  (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
+static bfd_boolean vms_bfd_print_private_bfd_data (bfd *abfd, void *file);
+static char *vms_core_file_failing_command (bfd *abfd);
+static int vms_core_file_failing_signal (bfd *abfd);
+static bfd_boolean vms_core_file_matches_executable_p (bfd *abfd, bfd *bbfd);
+static bfd_boolean vms_slurp_armap (bfd *abfd);
+static bfd_boolean vms_slurp_extended_name_table (bfd *abfd);
+static bfd_boolean vms_construct_extended_name_table
+  (bfd *abfd, char **tabloc, bfd_size_type *tablen, const char **name);
+static void vms_truncate_arname (bfd *abfd, const char *pathname, char *arhdr);
+static bfd_boolean vms_write_armap
+  (bfd *arch, unsigned int elen, struct orl *map, unsigned int cnt, int idx);
+static PTR vms_read_ar_hdr (bfd *abfd);
+static bfd *vms_get_elt_at_index (bfd *abfd, symindex index);
+static bfd *vms_openr_next_archived_file (bfd *arch, bfd *prev);
+static bfd_boolean vms_update_armap_timestamp (bfd *abfd);
+static int vms_generic_stat_arch_elt (bfd *, struct stat *);
+static long vms_get_symtab_upper_bound (bfd *abfd);
+static long vms_canonicalize_symtab (bfd *abfd, asymbol **symbols);
+static void vms_print_symbol (bfd *abfd, PTR file, asymbol *symbol,
+			      bfd_print_symbol_type how);
+static void vms_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret);
+static bfd_boolean vms_bfd_is_local_label_name (bfd *abfd, const char *);
+static alent *vms_get_lineno (bfd *abfd, asymbol *symbol);
+static bfd_boolean vms_find_nearest_line
+  (bfd *abfd, asection *section, asymbol **symbols, bfd_vma offset,
+   const char **file, const char **func, unsigned int *line);
+static asymbol *vms_bfd_make_debug_symbol (bfd *abfd, void *ptr,
+					   unsigned long size);
+static long vms_read_minisymbols (bfd *abfd, bfd_boolean dynamic,
+				  PTR *minisymsp, unsigned int *sizep);
+static asymbol *vms_minisymbol_to_symbol
+  (bfd *abfd, bfd_boolean dynamic, const PTR minisym, asymbol *sym);
+static void alloc_reloc_stream (bfd *abfd, asection *section,
+				void *alloc_error);
+static bfd_boolean vms_slurp_reloc_table (bfd *abfd, asection *section,
+					  asymbol **symbols);
+static long vms_get_reloc_upper_bound (bfd *abfd, asection *sect);
+static long vms_canonicalize_reloc (bfd *abfd, asection *srcsec,
+				    arelent **location, asymbol **symbols);
+static const struct reloc_howto_struct *vms_bfd_reloc_type_lookup
+  (bfd *abfd, bfd_reloc_code_real_type code);
+static bfd_boolean vms_set_arch_mach
+  (bfd *abfd, enum bfd_architecture arch, unsigned long mach);
+static bfd_boolean vms_set_section_contents
+  (bfd *abfd, asection *section, const PTR location, file_ptr offset,
+   bfd_size_type count);
+static int vms_sizeof_headers (bfd *abfd,
+			       struct bfd_link_info *info ATTRIBUTE_UNUSED);
+static bfd_byte *vms_bfd_get_relocated_section_contents
+  (bfd *abfd, struct bfd_link_info *link_info,
+   struct bfd_link_order *link_order, bfd_byte *data,
+   bfd_boolean relocatable, asymbol **symbols);
+static bfd_boolean vms_bfd_relax_section
+  (bfd *abfd, asection *section, struct bfd_link_info *link_info,
+   bfd_boolean *again);
+static bfd_boolean vms_bfd_gc_sections
+  (bfd *abfd, struct bfd_link_info *link_info);
+static bfd_boolean vms_bfd_merge_sections
+  (bfd *abfd, struct bfd_link_info *link_info);
+static struct bfd_link_hash_table *vms_bfd_link_hash_table_create (bfd *abfd);
+static void vms_bfd_link_hash_table_free (struct bfd_link_hash_table *hash);
+static bfd_boolean vms_bfd_link_add_symbols
+  (bfd *abfd, struct bfd_link_info *link_info);
+static bfd_boolean vms_bfd_final_link (bfd *abfd,
+				       struct bfd_link_info *link_info);
+static bfd_boolean vms_bfd_link_split_section (bfd *abfd, asection *section);
+static long vms_get_dynamic_symtab_upper_bound (bfd *abfd);
+static long vms_canonicalize_dynamic_symtab
+  (bfd *abfd, asymbol **symbols);
+#define vms_get_synthetic_symtab _bfd_nodynamic_get_synthetic_symtab
+static long vms_get_dynamic_reloc_upper_bound (bfd *abfd);
+static long vms_canonicalize_dynamic_reloc
+  (bfd *abfd, arelent **arel, asymbol **symbols);
+static bfd_boolean vms_bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
+static bfd_boolean vms_bfd_set_private_flags (bfd *abfd, flagword flags);
+
 #define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
 #define vms_make_empty_symbol             _bfd_generic_make_empty_symbol
 #define vms_bfd_link_just_syms            _bfd_generic_link_just_syms
@@ -36,42 +147,38 @@
 #define vms_bfd_copy_private_header_data  _bfd_generic_bfd_copy_private_header_data
 #define vms_get_synthetic_symtab          _bfd_nodynamic_get_synthetic_symtab
 
-static unsigned int priv_section_count;
+
+#ifdef VMS_DEBUG
+/* Cause debug info to be emitted for the structure.  */
+struct vms_private_data_struct _vms_private_data_struct_dummy;
+struct vms_section_data_struct _vms_section_data_struct_dummy;
+#endif
+
 extern const bfd_target vms_vax_vec;
 extern const bfd_target vms_alpha_vec;
-
-/* Initialize private data.  */
 
+/* Initialize private data  */
 static bfd_boolean
 vms_initialize (bfd * abfd)
 {
-  int i;
   bfd_size_type amt;
 
   bfd_set_start_address (abfd, (bfd_vma) -1);
 
   amt = sizeof (struct vms_private_data_struct);
-  abfd->tdata.any = bfd_alloc (abfd, amt);
+  abfd->tdata.any = bfd_zalloc (abfd, amt);
   if (abfd->tdata.any == NULL)
     return FALSE;
 
-#ifdef __ALPHA
-  PRIV (is_vax) = FALSE;
-#else
-  PRIV (is_vax) = TRUE;
-#endif
-  PRIV (vms_buf) = NULL;
-  PRIV (buf_size) = 0;
-  PRIV (rec_length) = 0;
+  if (bfd_get_flavour (abfd) == bfd_target_ovax_flavour)
+    PRIV (is_vax) = TRUE;
+
   PRIV (file_format) = FF_UNKNOWN;
-  PRIV (fixup_done) = FALSE;
-  PRIV (sections) = NULL;
 
   amt = sizeof (struct stack_struct) * STACKSIZE;
   PRIV (stack) = bfd_alloc (abfd, amt);
   if (PRIV (stack) == NULL)
     goto error_ret1;
-  PRIV (stackptr) = 0;
 
   amt = sizeof (struct bfd_hash_table);
   PRIV (vms_symbol_table) = bfd_alloc (abfd, amt);
@@ -82,24 +189,12 @@ vms_initialize (bfd * abfd)
 			    sizeof (vms_symbol_entry)))
     goto error_ret1;
 
-  amt = sizeof (struct location_struct) * LOCATION_SAVE_SIZE;
-  PRIV (location_stack) = bfd_alloc (abfd, amt);
-  if (PRIV (location_stack) == NULL)
-    goto error_ret2;
-
-  for (i = 0; i < VMS_SECTION_COUNT; i++)
-    PRIV (vms_section_table)[i] = NULL;
-
   amt = MAX_OUTREC_SIZE;
   PRIV (output_buf) = bfd_alloc (abfd, amt);
   if (PRIV (output_buf) == NULL)
     goto error_ret2;
 
-  PRIV (push_level) = 0;
-  PRIV (pushed_size) = 0;
   PRIV (length_pos) = 2;
-  PRIV (output_size) = 0;
-  PRIV (output_alignment) = 1;
 
   return TRUE;
 
@@ -111,154 +206,127 @@ vms_initialize (bfd * abfd)
   return FALSE;
 }
 
-/* Fill symbol->section with section ptr
+struct pair
+{
+  unsigned int section_count;
+  asection **sections;
+};
+
+/* Fill symbol->section with section pointer.
+
    symbol->section is filled with the section index for defined symbols
-   during reading the GSD/EGSD section. But we need the pointer to the
+   during reading the GSD/EGSD section.  But we need the pointer to the
    bfd section later.
 
-   It has the correct value for referenced (undefined section) symbols
+   It has the correct value for referenced (undefined section) symbols.
 
-   called from bfd_hash_traverse in vms_fixup_sections.  */
+   Called from bfd_hash_traverse in vms_fixup_sections.  */
 
 static bfd_boolean
-fill_section_ptr (struct bfd_hash_entry * entry, void * sections)
+fill_section_ptr (struct bfd_hash_entry *entry, void *sections)
 {
-  asection *sec;
-  asymbol *sym;
-
-  sym = ((vms_symbol_entry *) entry)->symbol;
-  sec = sym->section;
+  asymbol *sym = ((vms_symbol_entry *)entry)->symbol;
+  struct pair *data = (struct pair *)sections;
+  unsigned long sec = (unsigned long)sym->section;
 
 #if VMS_DEBUG
   vms_debug (6, "fill_section_ptr: sym %p, sec %p\n", sym, sec);
 #endif
 
-  /* Fill forward references (these contain section number, not section ptr).  */
-  if ((unsigned int) (size_t) sec < priv_section_count)
-    sec = ((vms_symbol_entry *) entry)->symbol->section =
-      ((asection **) sections)[(unsigned int) (size_t) sec];
-
-  if (strcmp (sym->name, sec->name) == 0)
-    sym->flags |= BSF_SECTION_SYM;
+  if (sec < data->section_count)
+    {
+      sym->section = data->sections[sec];
 
+      if (strcmp (sym->name, sym->section->name) == 0)
+	sym->flags |= BSF_SECTION_SYM;
+    }
+  else if (sec == (unsigned long)-1)
+    sym->section = &bfd_und_section;
+    
   return TRUE;
 }
 
-/* Fixup sections
-   set up all pointers and arrays, counters and sizes are fixed now
-
-   we build a private sections vector for easy access since sections
-   are always referenced by an index number.
-
-   alloc PRIV(sections) according to abfd->section_count
-	copy abfd->sections to PRIV(sections).  */
-
+/* Fixup section pointers in symbols.  */
 static bfd_boolean
 vms_fixup_sections (bfd * abfd)
 {
+  struct pair data;
+
   if (PRIV (fixup_done))
     return TRUE;
 
-  /* Traverse symbol table and fill in all section pointers.  */
-
-  /* Can't provide section count as argument to fill_section_ptr().  */
-  priv_section_count = PRIV (section_count);
-  bfd_hash_traverse (PRIV (vms_symbol_table), fill_section_ptr, (PRIV (sections)));
+  data.section_count = PRIV (section_count);
+  data.sections = PRIV (sections);
+  bfd_hash_traverse (PRIV (vms_symbol_table), fill_section_ptr, &data);
 
   PRIV (fixup_done) = TRUE;
-
   return TRUE;
 }
-
-/* Check the format for a file being read.
-   Return a (bfd_target *) if it's an object file or zero if not.  */
 
-static const struct bfd_target *
-vms_object_p (bfd * abfd)
+/* Slurp an ordered set of VMS object records.  */
+int
+_bfd_vms_slurp_object_records (bfd * abfd)
 {
-  int err = 0;
-  int prev_type;
-  const struct bfd_target *target_vector = NULL;
-  const bfd_arch_info_type *arch = NULL;
-  void * tdata_save = abfd->tdata.any;
-  bfd_vma saddr_save = bfd_get_start_address (abfd);
-
-#if VMS_DEBUG
-  vms_debug (1, "vms_object_p (%p)\n", abfd);
-#endif
-
-  if (!vms_initialize (abfd))
-    goto error_ret;
-
-  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
-    goto err_wrong_format;
-
-  prev_type = -1;
+  int err, new_type, type = -1;
 
   do
     {
 #if VMS_DEBUG
       vms_debug (7, "reading at %08lx\n", bfd_tell (abfd));
 #endif
-      if (_bfd_vms_next_record (abfd) < 0)
+      new_type = _bfd_vms_get_object_record (abfd);
+      if (new_type < 0)
 	{
 #if VMS_DEBUG
 	  vms_debug (2, "next_record failed\n");
 #endif
-	  goto err_wrong_format;
+	  return -1;
 	}
 
-      if ((prev_type == EOBJ_S_C_EGSD)
-	   && (PRIV (rec_type) != EOBJ_S_C_EGSD))
+      if (type == EOBJ_S_C_EGSD && new_type != EOBJ_S_C_EGSD)
 	{
 	  if (! vms_fixup_sections (abfd))
 	    {
 #if VMS_DEBUG
 	      vms_debug (2, "vms_fixup_sections failed\n");
 #endif
-	      goto err_wrong_format;
+	      return -1;
 	    }
 	}
 
-      prev_type = PRIV (rec_type);
-
-      if (target_vector == NULL)
-	{
-	  if (prev_type <= OBJ_S_C_MAXRECTYP)
-	    target_vector = & vms_vax_vec;
-	  else
-	    target_vector = & vms_alpha_vec;
-	}
+      type = new_type;
 
-      switch (prev_type)
+      switch (type)
 	{
 	  case OBJ_S_C_HDR:
 	  case EOBJ_S_C_EMH:
-	    err = _bfd_vms_slurp_hdr (abfd, prev_type);
+	    err = _bfd_vms_slurp_hdr (abfd, type);
 	    break;
 	  case OBJ_S_C_EOM:
 	  case OBJ_S_C_EOMW:
 	  case EOBJ_S_C_EEOM:
-	    err = _bfd_vms_slurp_eom (abfd, prev_type);
+	    err = _bfd_vms_slurp_eom (abfd, type);
 	    break;
 	  case OBJ_S_C_GSD:
 	  case EOBJ_S_C_EGSD:
-	    err = _bfd_vms_slurp_gsd (abfd, prev_type);
+	    err = _bfd_vms_slurp_gsd (abfd, type);
 	    break;
 	  case OBJ_S_C_TIR:
 	  case EOBJ_S_C_ETIR:
-	    err = _bfd_vms_slurp_tir (abfd, prev_type);
+	    err = _bfd_vms_slurp_tir (abfd, type);
 	    break;
 	  case OBJ_S_C_DBG:
 	  case EOBJ_S_C_EDBG:
-	    err = _bfd_vms_slurp_dbg (abfd, prev_type);
+	    err = _bfd_vms_slurp_dbg (abfd, type);
+	    PRIV (dst_ptr_end) = PRIV (image_ptr);
 	    break;
 	  case OBJ_S_C_TBT:
 	  case EOBJ_S_C_ETBT:
-	    err = _bfd_vms_slurp_tbt (abfd, prev_type);
+	    err = _bfd_vms_slurp_tbt (abfd, type);
+	    PRIV (dst_ptr_end) = PRIV (image_ptr);
 	    break;
 	  case OBJ_S_C_LNK:
-	    err = _bfd_vms_slurp_lnk (abfd, prev_type);
+	    err = _bfd_vms_slurp_lnk (abfd, type);
 	    break;
 	  default:
 	    err = -1;
@@ -266,14 +334,105 @@ vms_object_p (bfd * abfd)
       if (err != 0)
 	{
 #if VMS_DEBUG
-	  vms_debug (2, "slurp type %d failed with %d\n", prev_type, err);
+	  vms_debug (2, "slurp type %d failed with %d\n", type, err);
 #endif
-	  goto err_wrong_format;
+	  return err;
 	}
     }
-  while ((prev_type != EOBJ_S_C_EEOM) && (prev_type != OBJ_S_C_EOM) && (prev_type != OBJ_S_C_EOMW));
+  while (type != EOBJ_S_C_EEOM && type != OBJ_S_C_EOM && type != OBJ_S_C_EOMW);
+
+  return 0;
+}
+
+/* Slurp a VMS module and return an error status.  */
+
+static int
+vms_slurp_module (bfd *abfd)
+{
+  int type, err;
+
+  if (PRIV (is_vax))
+    type = PRIV (vms_rec)[0];
+  else
+    type = bfd_getl16 (PRIV (vms_rec));
+
+  err = _bfd_vms_slurp_hdr (abfd, type);
+  if (err != 0)
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return err;
+    }
+
+  return _bfd_vms_slurp_object_records (abfd);
+}
+
+/* Slurp a VMS image and return an error status.  */
+
+static int
+vms_slurp_image (bfd *abfd)
+{
+  unsigned int isd_offset, ihs_offset;
+  int err;
+
+  err = _bfd_vms_slurp_ihd (abfd, &isd_offset, &ihs_offset);
+  if (err != 0)
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return err;
+    }
 
-  if (target_vector == & vms_vax_vec)
+  err = _bfd_vms_slurp_isd (abfd, isd_offset);
+  if (err != 0)
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return err;
+    }
+
+  return _bfd_vms_slurp_ihs (abfd, ihs_offset);
+}
+
+/* Check the format for a file being read.
+   Return a (bfd_target *) if it's an object file or zero if not.  */
+
+static const struct bfd_target *
+vms_object_p (bfd *abfd)
+{
+  const struct bfd_target *target_vector;
+  const bfd_arch_info_type *arch;
+  PTR tdata_save = abfd->tdata.any;
+  bfd_vma saddr_save = bfd_get_start_address (abfd);
+  int err = 0;
+
+#if VMS_DEBUG
+  vms_debug (1, "vms_object_p(%p)\n", abfd);
+#endif
+
+  if (!vms_initialize (abfd))
+    goto error_ret;
+
+  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
+    goto err_wrong_format;
+
+  switch (_bfd_vms_get_first_record (abfd))
+    {
+    case FT_UNKNOWN:
+    default:
+      err = -1;
+      break;
+
+    case FT_MODULE:
+      err = vms_slurp_module (abfd);
+      break;
+
+    case FT_IMAGE:
+      err = vms_slurp_image (abfd);
+      break;
+    }
+
+  if (err != 0)
+    goto err_wrong_format;
+
+  if (PRIV (is_vax))
     {
       if (! vms_fixup_sections (abfd))
 	{
@@ -283,38 +442,29 @@ vms_object_p (bfd * abfd)
 	  goto err_wrong_format;
 	}
 
-      /* Set arch_info to vax.  */
-
+      target_vector = &vms_vax_vec;
       arch = bfd_scan_arch ("vax");
-      PRIV (is_vax) = TRUE;
+
 #if VMS_DEBUG
       vms_debug (2, "arch is vax\n");
 #endif
     }
-  else if (target_vector == & vms_alpha_vec)
+  else
     {
       /* Set arch_info to alpha.   */
-
+      target_vector = &vms_alpha_vec;
       arch = bfd_scan_arch ("alpha");
-      PRIV (is_vax) = FALSE;
 #if VMS_DEBUG
       vms_debug (2, "arch is alpha\n");
 #endif
     }
 
-  if (arch == NULL)
-    {
-#if VMS_DEBUG
-      vms_debug (2, "arch not found\n");
-#endif
-      goto err_wrong_format;
-    }
   abfd->arch_info = arch;
-
   return target_vector;
 
  err_wrong_format:
   bfd_set_error (bfd_error_wrong_format);
+
  error_ret:
   if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
     bfd_release (abfd, abfd->tdata.any);
@@ -341,6 +491,8 @@ vms_archive_p (bfd * abfd ATTRIBUTE_UNUSED)
 static bfd_boolean
 vms_mkobject (bfd * abfd)
 {
+  const bfd_arch_info_type *arch;
+
 #if VMS_DEBUG
   vms_debug (1, "vms_mkobject (%p)\n", abfd);
 #endif
@@ -348,20 +500,18 @@ vms_mkobject (bfd * abfd)
   if (!vms_initialize (abfd))
     return FALSE;
 
-  {
-#ifdef __VAX
-    const bfd_arch_info_type *arch = bfd_scan_arch ("vax");
-#else
-    const bfd_arch_info_type *arch = bfd_scan_arch ("alpha");
-#endif
-    if (arch == NULL)
-      {
-	bfd_set_error (bfd_error_wrong_format);
-	return FALSE;
-      }
-    abfd->arch_info = arch;
-  }
+  if (PRIV (is_vax))
+    arch = bfd_scan_arch ("vax");
+  else
+    arch = bfd_scan_arch ("alpha");
+
+  if (arch == 0)
+    {
+      bfd_set_error(bfd_error_wrong_format);
+      return FALSE;
+    }
 
+  abfd->arch_info = arch;
   return TRUE;
 }
 
@@ -420,6 +570,62 @@ vms_write_object_contents (bfd * abfd)
 
 /* 4.1, generic.  */
 
+/* Free the reloc buffer for the specified section.  */
+
+static void
+free_reloc_stream (bfd *abfd ATTRIBUTE_UNUSED, asection *section,
+		   void *data ATTRIBUTE_UNUSED)
+{
+  if (vms_section_data (section)->reloc_stream)
+    free (vms_section_data (section)->reloc_stream);
+}
+
+#ifdef VMS
+/* Convert the file to variable record length format. This is done
+   using undocumented system call sys$modify().
+   Pure VMS version.  */
+
+static void
+vms_convert_to_var (char *vms_filename)
+{
+  struct FAB fab = cc$rms_fab;
+
+  fab.fab$l_fna = vms_filename;
+  fab.fab$b_fns = strlen (vms_filename);
+  fab.fab$b_fac = FAB$M_PUT;
+  fab.fab$l_fop = FAB$M_ESC;
+  fab.fab$l_ctx = RME$C_SETRFM;
+  
+  sys$open (&fab);
+  
+  fab.fab$b_rfm = FAB$C_VAR;
+  
+  sys$modify (&fab);
+  sys$close (&fab);
+}
+
+static int
+vms_convert_to_var_1 (char *filename, int type)
+{
+  if (type != DECC$K_FILE)
+    return FALSE;
+  vms_convert_to_var (filename);
+  return TRUE;
+}
+
+/* Convert the file to variable record length format. This is done
+   using undocumented system call sys$modify().
+   Unix filename version.  */
+
+static int
+vms_convert_to_var_unix_filename (const char *unix_filename)
+{
+  if (decc$to_vms (unix_filename, &vms_convert_to_var_1, 0, 1) != 1)
+    return FALSE;
+  return TRUE;
+}
+#endif /* VMS */
+
 /* Called when the BFD is being closed to do any necessary cleanup.  */
 
 static bfd_boolean
@@ -428,8 +634,7 @@ vms_close_and_cleanup (bfd * abfd)
 #if VMS_DEBUG
   vms_debug (1, "vms_close_and_cleanup (%p)\n", abfd);
 #endif
-  if (abfd == NULL
-      || abfd->tdata.any == NULL)
+  if (abfd == NULL || abfd->tdata.any == NULL)
     return TRUE;
 
   if (PRIV (vms_buf) != NULL)
@@ -441,9 +646,23 @@ vms_close_and_cleanup (bfd * abfd)
   if (PRIV (vms_symbol_table))
     bfd_hash_table_free (PRIV (vms_symbol_table));
 
+  bfd_map_over_sections (abfd, free_reloc_stream, NULL);
+
   bfd_release (abfd, abfd->tdata.any);
   abfd->tdata.any = NULL;
 
+#ifdef VMS
+  if (abfd->direction == write_direction)
+    {
+      /* Last step on VMS is to convert the file to variable record length
+	 format.  */
+      if (bfd_cache_close (abfd) != TRUE)
+	return FALSE;
+      if (vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
+	return FALSE;
+    }
+#endif
+
   return TRUE;
 }
 
@@ -463,6 +682,8 @@ vms_bfd_free_cached_info (bfd * abfd ATTRIBUTE_UNUSED)
 static bfd_boolean
 vms_new_section_hook (bfd * abfd, asection *section)
 {
+  bfd_size_type amt;
+
   /* Count hasn't been incremented yet.  */
   unsigned int section_count = abfd->section_count + 1;
 
@@ -470,7 +691,8 @@ vms_new_section_hook (bfd * abfd, asection *section)
   vms_debug (1, "vms_new_section_hook (%p, [%d]%s), count %d\n",
 	     abfd, section->index, section->name, section_count);
 #endif
-  bfd_set_section_alignment (abfd, section, 4);
+
+  bfd_set_section_alignment (abfd, section, 0);
 
   if (section_count > PRIV (section_count))
     {
@@ -481,14 +703,22 @@ vms_new_section_hook (bfd * abfd, asection *section)
 	return FALSE;
       PRIV (section_count) = section_count;
     }
+
 #if VMS_DEBUG
   vms_debug (6, "section_count: %d\n", PRIV (section_count));
 #endif
+
   PRIV (sections)[section->index] = section;
+
 #if VMS_DEBUG
   vms_debug (7, "%d: %s\n", section->index, section->name);
 #endif
 
+  amt = sizeof (struct vms_section_data_struct);
+  section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
+  if (section->used_by_bfd == NULL)
+    return FALSE;
+
   return _bfd_generic_new_section_hook (abfd, section);
 }
 
@@ -503,13 +733,42 @@ vms_get_section_contents (bfd * abfd ATTRIBUTE_UNUSED,
 			  file_ptr offset ATTRIBUTE_UNUSED,
 			  bfd_size_type buf_size ATTRIBUTE_UNUSED)
 {
+  bfd_size_type size = section->size;
+
 #if VMS_DEBUG
   vms_debug (1, "vms_get_section_contents (%p, %s, %p, off %ld, size %d)\n",
 		 abfd, section->name, buf, offset, (int)buf_size);
 #endif
 
-  /* Shouldn't be called, since all sections are IN_MEMORY.  */
-  return FALSE;
+  if (section->contents)
+    abort ();
+
+  section->contents = (unsigned char *) bfd_malloc (size);
+
+  if (section->contents == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return FALSE;
+    }
+
+  if (bfd_seek (abfd, section->filepos, SEEK_SET))
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      return FALSE;
+    }
+
+  if (bfd_bread (section->contents, size, abfd) != size)
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      return FALSE;
+    }
+
+  section->flags |= SEC_IN_MEMORY;
+
+  if (buf)
+    memcpy (buf, section->contents + offset, (size_t) buf_size);
+
+  return TRUE;
 }
 
 /* Read the contents of a section.
@@ -703,7 +962,6 @@ vms_truncate_arname (bfd * abfd ATTRIBUTE_UNUSED,
 #if VMS_DEBUG
   vms_debug (1, "vms_truncate_arname (%p, %s, %s)\n", abfd, pathname, arhdr);
 #endif
-  return;
 }
 
 /* ???	write archive map.  */
@@ -906,7 +1164,9 @@ vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED,
   if (ret == NULL)
     return;
 
-  if (bfd_is_com_section (sec))
+  if (sec == 0)
+    ret->type = 'U';
+  else if (bfd_is_com_section (sec))
     ret->type = 'C';
   else if (bfd_is_abs_section (sec))
     ret->type = 'A';
@@ -972,7 +1232,7 @@ vms_find_nearest_line (bfd * abfd ATTRIBUTE_UNUSED,
   vms_debug (1, "vms_find_nearest_line (%p, %s, %p, %ld, <ret>, <ret>, <ret>)\n",
 	      abfd, section->name, symbols, (long int)offset);
 #endif
-  return FALSE;
+  return _bfd_vms_find_nearest_dst_line (abfd, section, symbols, offset, file, func, line);
 }
 
 static bfd_boolean
@@ -1037,36 +1297,160 @@ vms_minisymbol_to_symbol (bfd * abfd,
 
 /* Part 4.6, relocations.  */
 
-/* Return the number of bytes required to store the relocation information
-   associated with section sect attached to bfd abfd.
-   If an error occurs, return -1.  */
+/* Allocate the reloc buffer for the specified section.  */
 
-static long
-vms_get_reloc_upper_bound (bfd * abfd ATTRIBUTE_UNUSED,
-			   asection *section ATTRIBUTE_UNUSED)
+static void
+alloc_reloc_stream (bfd *abfd ATTRIBUTE_UNUSED, asection *section,
+		    void *alloc_error)
 {
+  unsigned char *ptr;
+
+  /* If there were no relocations, there is nothing to do.  */
+  if (section->reloc_count == 0)
+    return;
+
+  ptr = bfd_malloc (vms_section_data (section)->reloc_size);
+  if (ptr == NULL)
+    {
+      *(bfd_boolean *)alloc_error = TRUE;
+      return;
+    }
+
+  vms_section_data (section)->reloc_stream = ptr;
+}
+
+/* Read in the relocs for the specified section and internalize them.
+
+   The implementation is loosely based on the SOM code and made up
+   of 3 distinct phases:
+
+   1. When the VMS object is opened and parsed, the number and the size
+      of the relocations are computed for all sections.  This makes it
+      possible to know upfront both which sections have no relocs and
+      the size of the reloc buffers for the other sections, at virtually
+      no cost for consumers that don't care about relocs at all.
+
+   2. When vms_slurp_reloc_table is invoked for the first time on a section
+      with relocs, the object is traversed and all the reloc information
+      is saved in per-section reloc buffers.  It would be very inefficient
+      to scan the whole file on each invocation, so we slurp for all the
+      sections at once.
+
+   3. On subsequent invocations of vms_slurp_reloc_table, the relocs for the
+      specified section are fetched from the buffer, decoded and internalized.
+      The buffer is then freed since the internalized relocs are attached to
+      the section, turning additional invocations of vms_slurp_reloc_table
+      on the same section into no-ops.
+
+   Since VMS objects have very few sections, it could be profitable to merge
+   phase #2 and phase #3, i.e. to decode and internalize the relocs for all
+   the sections at once.  The current implementation is more elegant.  */
+
+static bfd_boolean
+vms_slurp_reloc_table (bfd *abfd, asection *section, asymbol **symbols)
+{
+  arelent *internal_relocs;
+  bfd_size_type amt;
+  int err;
+
+  /* If there were no relocations, there is nothing to do.  */
+  if (section->reloc_count == 0)
+    return TRUE;
+
+  /* Return saved information about the relocations if it is available.  */
+  if (section->relocation != NULL)
+    return TRUE;
+
+  /* If the relocation stream has not been slurped, do it now.  */
+  if (vms_section_data (section)->reloc_stream == NULL)
+    {
+      bfd_boolean alloc_error = FALSE;
+      int type;
+
+      /* Size the reloc buffer for each section.  */
+      bfd_map_over_sections (abfd, alloc_reloc_stream, &alloc_error);
+      if (alloc_error)
+	return FALSE;
+
+      if (bfd_seek (abfd, 0, SEEK_SET) != 0)
+	return FALSE;
+
+      /* Reset section pointer.  */
+      PRIV (image_section) = NULL;
+
+      do
+	{
+	  type = _bfd_vms_get_object_record (abfd);
+	  if (type != EOBJ_S_C_ETIR
+	      && type != EOBJ_S_C_EDBG
+	      && type != EOBJ_S_C_ETBT)
+	    continue;
+	  err = _bfd_vms_slurp_relocs (abfd);
+	  if (err != 0)
+	    {
+#if VMS_DEBUG
+	      vms_debug (2, "slurp relocs failed with %d\n", err);
+#endif
+	      return FALSE;
+	    }
+	}
+      while (type != EOBJ_S_C_EEOM);
+    }
+
+  amt = section->reloc_count * sizeof (arelent);
+  internal_relocs = (arelent *) bfd_zalloc (abfd, amt);
+  if (internal_relocs == NULL)
+    return FALSE;
+
+  /* Decode and internalize the relocations.  */
+  err = _bfd_vms_decode_relocs (abfd, internal_relocs, section, symbols);
+  if (err != 0)
+    {
 #if VMS_DEBUG
-  vms_debug (1, "vms_get_reloc_upper_bound (%p, %s)\n", abfd, section->name);
+      vms_debug (2, "decode relocs failed with %d\n", err);
 #endif
-  return -1L;
+      return FALSE;
+    }
+
+  /* We're done with the external relocations.  Free them.  */
+  free (vms_section_data (section)->reloc_stream);
+  vms_section_data (section)->reloc_stream = NULL;
+
+  /* Save our results and return success.  */
+  section->relocation = internal_relocs;
+  return TRUE;
 }
 
-/* Call the back end associated with the open BFD abfd and translate the
-   external form of the relocation information attached to sec into the
-   internal canonical form.  Place the table into memory at loc, which has
-   been preallocated, usually by a call to bfd_get_reloc_upper_bound.
-   Returns the number of relocs, or -1 on error.  */
+/* Return the number of bytes required to store the relocation
+   information associated with the given section.  */
 
 static long
-vms_canonicalize_reloc (bfd * abfd ATTRIBUTE_UNUSED,
-			asection *section ATTRIBUTE_UNUSED,
-			arelent **location ATTRIBUTE_UNUSED,
-			asymbol **symbols ATTRIBUTE_UNUSED)
+vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
 {
-#if VMS_DEBUG
-  vms_debug (1, "vms_canonicalize_reloc (%p, %s, <ret>, <ret>)\n", abfd, section->name);
-#endif
-  return FALSE;
+  return (section->reloc_count + 1) * sizeof (arelent *);  
+}
+
+/* Convert relocations from VMS (external) form into BFD internal
+   form.  Return the number of relocations.  */
+
+static long
+vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
+			asymbol **symbols)
+{
+  arelent *tblptr;
+  int count;
+
+  if (! vms_slurp_reloc_table (abfd, section, symbols))
+    return -1;
+
+  count = section->reloc_count;
+  tblptr = section->relocation;
+
+  while (count--)
+    *relptr++ = tblptr++;
+
+  *relptr = (arelent *) NULL;
+  return section->reloc_count;
 }
 
 /* This is just copied from ecoff-alpha, needs to be fixed probably.  */
@@ -1317,6 +1701,64 @@ static reloc_howto_type alpha_howto_table[] =
 	 0xffffffff,		/* Dest mask.  */
 	 FALSE),		/* PC rel offset.  */
 
+  HOWTO (ALPHA_R_NOP,		/* Type.  */
+	 0,			/* Rightshift.  */
+	 3,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 0,			/* Bitsize.  */
+	 /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
+	    because the calculations for the 3 relocations are the same.
+	    See B.4.5.2 of the OpenVMS Linker Utility Manual.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.   */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "NOP",			/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0xffffffff,		/* Source mask.  */
+	 0xffffffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  HOWTO (ALPHA_R_BSR,		/* Type.  */
+	 0,			/* Rightshift.  */
+	 3,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 0,			/* Bitsize.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "BSR",			/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0xffffffff,		/* Source mask.  */
+	 0xffffffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  HOWTO (ALPHA_R_LDA,		/* Type.  */
+	 0,			/* Rightshift.  */
+	 3,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 0,			/* Bitsize.  */
+	 FALSE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "LDA",			/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0xffffffff,		/* Source mask.  */
+	 0xffffffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  HOWTO (ALPHA_R_BOH,		/* Type.  */
+	 0,			/* Rightshift.  */
+	 3,			/* Size (0 = byte, 1 = short, 2 = long, 3 = nil).  */
+	 0,			/* Bitsize.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "BOH",			/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0xffffffff,		/* Source mask.  */
+	 0xffffffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
 };
 
 /* Return a pointer to a howto structure which, when invoked, will perform
@@ -1345,6 +1787,10 @@ vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
       case BFD_RELOC_64_PCREL:		alpha_type = ALPHA_R_SREL64;	break;
       case BFD_RELOC_ALPHA_LINKAGE:	alpha_type = ALPHA_R_LINKAGE;	break;
       case BFD_RELOC_ALPHA_CODEADDR:	alpha_type = ALPHA_R_CODEADDR;	break;
+      case BFD_RELOC_ALPHA_NOP:		alpha_type = ALPHA_R_NOP;	break;
+      case BFD_RELOC_ALPHA_BSR:		alpha_type = ALPHA_R_BSR;	break;
+      case BFD_RELOC_ALPHA_LDA:		alpha_type = ALPHA_R_LDA;	break;
+      case BFD_RELOC_ALPHA_BOH:		alpha_type = ALPHA_R_BOH;	break;
       default:
 	(*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
 	return NULL;
@@ -1385,14 +1831,18 @@ vms_set_arch_mach (bfd * abfd,
 #if VMS_DEBUG
   vms_debug (1, "vms_set_arch_mach (%p, %d, %ld)\n", abfd, arch, mach);
 #endif
-  abfd->arch_info = bfd_scan_arch ("alpha");
 
-  return TRUE;
+  if (arch != bfd_arch_alpha
+      && arch != bfd_arch_vax
+      && arch != bfd_arch_unknown)
+    return FALSE;
+
+  return bfd_default_set_arch_mach (abfd, arch, mach);
 }
 
 /* Sets the contents of the section section in BFD abfd to the data starting
-   in memory at data. The data is written to the output section starting at
-   offset offset for count bytes.
+   in memory at LOCATION. The data is written to the output section starting
+   at offset offset for count bytes.
 
    Normally TRUE is returned, else FALSE. Possible error returns are:
    o bfd_error_no_contents - The output section does not have the
@@ -1411,7 +1861,16 @@ vms_set_section_contents (bfd * abfd,
 	     abfd, section->name, location, (long int)offset, (int)count);
   vms_debug (2, "size %d\n", (int) section->size);
 #endif
-  return _bfd_save_vms_section (abfd, section, location, offset, count);
+  if (count == (bfd_size_type)0)
+    return TRUE;
+
+  if (section->contents == NULL)
+    section->contents = bfd_alloc (abfd, section->size);
+  if (section->contents == NULL)
+    return FALSE;
+
+  memcpy (section->contents + offset, location, (size_t) count);
+  return TRUE;
 }
 
 /* Part 4.8, linker.  */
@@ -1550,7 +2009,7 @@ vms_get_dynamic_symtab_upper_bound (bfd * abfd ATTRIBUTE_UNUSED)
 #if VMS_DEBUG
   vms_debug (1, "vms_get_dynamic_symtab_upper_bound (%p)\n", abfd);
 #endif
-  return 0;
+  return 0L;
 }
 
 static bfd_boolean
@@ -1606,14 +2065,14 @@ const bfd_target vms_alpha_vec =
   BFD_ENDIAN_LITTLE,		/* Data byte order is little.  */
   BFD_ENDIAN_LITTLE,		/* Header byte order is little.  */
 
-  (HAS_RELOC | HAS_SYMS
+  (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
    | WP_TEXT | D_PAGED),	/* Object flags.  */
   (SEC_ALLOC | SEC_LOAD | SEC_RELOC
    | SEC_READONLY | SEC_CODE | SEC_DATA
    | SEC_HAS_CONTENTS | SEC_IN_MEMORY),		/* Sect flags.  */
-  0,				/* Symbol_leading_char.  */
-  ' ',				/* AR_pad_char.  */
-  15,				/* AR_max_namelen.  */
+  0,				/* symbol_leading_char.  */
+  ' ',				/* ar_pad_char.  */
+  15,				/* ar_max_namelen.  */
   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
@@ -1640,7 +2099,7 @@ const bfd_target vms_alpha_vec =
 
   NULL,
 
-  NULL
+  (PTR) 0
 };
 
 const bfd_target vms_vax_vec =
@@ -1657,15 +2116,15 @@ const bfd_target vms_vax_vec =
   (SEC_ALLOC | SEC_LOAD | SEC_RELOC
    | SEC_READONLY | SEC_CODE | SEC_DATA
    | SEC_HAS_CONTENTS | SEC_IN_MEMORY),		/* Sect flags.  */
-  0,				/* Symbol_leading_char.  */
-  ' ',				/* AR_pad_char.  */
-  15,				/* AR_max_namelen.  */
+  0,				/* symbol_leading_char */
+  ' ',				/* ar_pad_char */
+  15,				/* ar_max_namelen */
   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
   bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
-  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers.  */
+  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Hdrs.  */
 
   {_bfd_dummy_target, vms_object_p,		/* bfd_check_format.  */
    vms_archive_p, _bfd_dummy_target},
@@ -1686,5 +2145,5 @@ const bfd_target vms_vax_vec =
 
   NULL,
 
-  NULL
+  (PTR) 0
 };
diff --git a/bfd/vms.h b/bfd/vms.h
index 2235540..b7d9344 100644
--- a/bfd/vms.h
+++ b/bfd/vms.h
@@ -1,6 +1,8 @@
 /* vms.h -- Header file for VMS (Alpha and Vax) support.
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2007
-   Free Software Foundation, Inc.
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2007,
+   2008, 2009 Free Software Foundation, Inc.
+
+   Main header file.
 
    Written by Klaus K"ampf (kkaempf@rmi.de)
 
@@ -25,9 +27,12 @@
 #ifndef VMS_H
 #define VMS_H
 
-/* Constants starting with 'Exxx_' are for openVMS/Alpha (EVAX object language)  */
+/* Constants starting with 'Exxx_' are for openVMS/Alpha (EVAX object
+   language).  */
+
+#define VMS_BLOCK_SIZE  512
 
-/* VMS Text, information and relocation record (TIR/ETIR) definitions.  */
+/* VMS Text Information and Relocation Records (TIR/ETIR).  */
 
 #define TIR_S_C_STA_GBL		0
 #define TIR_S_C_STA_SB		1
@@ -107,7 +112,7 @@
 #define ETIR_S_C_STA_GBL 0		/* Stack global symbol value.	*/
 #define ETIR_S_C_STA_LW 1		/* Stack longword.		*/
 #define ETIR_S_C_STA_QW 2		/* Stack quadword.		*/
-#define ETIR_S_C_STA_PQ 3		/* Stack psect base plus quadword offset.  */
+#define ETIR_S_C_STA_PQ 3		/* Stack psect base + quadword off.  */
 #define ETIR_S_C_STA_LI 4		/* Stack literal.		*/
 #define ETIR_S_C_STA_MOD 5		/* Stack module.		*/
 #define ETIR_S_C_STA_CKARG 6		/* Check Arguments.		*/
@@ -173,7 +178,9 @@
 #define ETIR_S_C_STC_NBH_PS 214		/* Store-conditional NOP,BSR or HINT at psect + offset.  */
 #define ETIR_S_C_MAXSTCCOD 214		/* Maximum store-conditional code.   */
 
-/* VMS Global symbol definition record (GSD/EGSD).  */
+#define ETIR_S_C_HEADER_SIZE 4		/* Size of the header of a command */
+
+/* VMS Global Symbol Directory Records (GSD/EGSD).  */
 
 #define GSD_S_K_ENTRIES 1
 #define GSD_S_C_ENTRIES 1
@@ -206,6 +213,7 @@
 #define EGSD_S_C_SYMG 8		/* EGST - gst version of SYM.		*/
 #define EGSD_S_C_MAXRECTYP 8	/* Maximum entry type defined.		*/
 
+/* Program Section Definition.  */
 #define GPS_S_M_PIC     1
 #define GPS_S_M_LIB     2
 #define GPS_S_M_OVR     4
@@ -219,31 +227,41 @@
 #define GPS_S_K_NAME    9
 #define GPS_S_C_NAME    9
 
-#define EGPS_S_V_PIC	0x0001
-#define EGPS_S_V_LIB	0x0002
-#define EGPS_S_V_OVR	0x0004
-#define EGPS_S_V_REL	0x0008
-#define EGPS_S_V_GBL	0x0010
-#define EGPS_S_V_SHR	0x0020
-#define EGPS_S_V_EXE	0x0040
-#define EGPS_S_V_RD	0x0080
-#define EGPS_S_V_WRT	0x0100
-#define EGPS_S_V_VEC	0x0200
-#define EGPS_S_V_NOMOD	0x0400
-#define EGPS_S_V_COM	0x0800
-
+#define EGPS_S_B_ALIGN    4
+#define EGPS_S_W_FLAGS    6
+#define EGPS_S_L_ALLOC    8
+#define EGPS_S_B_NAMLNG  12
+
+#define EGPS_S_V_PIC		0x0001
+#define EGPS_S_V_LIB		0x0002
+#define EGPS_S_V_OVR		0x0004
+#define EGPS_S_V_REL		0x0008
+#define EGPS_S_V_GBL		0x0010
+#define EGPS_S_V_SHR		0x0020
+#define EGPS_S_V_EXE		0x0040
+#define EGPS_S_V_RD		0x0080
+#define EGPS_S_V_WRT		0x0100
+#define EGPS_S_V_VEC		0x0200
+#define EGPS_S_V_NOMOD		0x0400
+#define EGPS_S_V_COM		0x0800
+#define EGPS_S_V_ALLOC_64BIT	0x1000
+
+/* Symbol Defintion or Reference.  */
 #define GSY_S_M_WEAK    1
 #define GSY_S_M_DEF     2
 #define GSY_S_M_UNI     4
 #define GSY_S_M_REL     8
 
-#define EGSY_S_V_WEAK	0x0001
-#define EGSY_S_V_DEF	0x0002
-#define EGSY_S_V_UNI	0x0004
-#define EGSY_S_V_REL	0x0008
-#define EGSY_S_V_COMM	0x0010
-#define EGSY_S_V_VECEP	0x0020
-#define EGSY_S_V_NORM	0x0040
+#define EGSY_S_W_FLAGS  6
+
+#define EGSY_S_V_WEAK		0x0001
+#define EGSY_S_V_DEF		0x0002
+#define EGSY_S_V_UNI		0x0004
+#define EGSY_S_V_REL		0x0008
+#define EGSY_S_V_COMM		0x0010
+#define EGSY_S_V_VECEP		0x0020
+#define EGSY_S_V_NORM		0x0040
+#define EGSY_S_V_QUAD_VAL	0x0080
 
 #define LSY_S_M_DEF     2
 #define LSY_S_M_REL     8
@@ -251,10 +269,26 @@
 #define ENV_S_M_DEF     1
 #define ENV_S_M_NESTED  2
 
+/* Symbol Definition.  */
+#define ESDF_S_L_VALUE     8
+#define ESDF_S_L_PSINDX   28
+#define ESDF_S_B_NAMLNG   32
+
+/* Universal Symbol Definition.  */
+#define EGST_S_W_FLAGS    6
+#define EGST_S_Q_LP_1    16
+#define EGST_S_Q_LP_2    24
+#define EGST_S_L_PSINDX  32
+#define EGST_S_B_NAMLNG  36
+
+/* Symbol Reference.  */
+#define ESRF_S_B_NAMLNG   8
+
 /* Debugger symbol definitions:  These are done by hand,
    as no machine-readable version seems to be available.  */
 #define DST_S_C_C		  7	/* Language == "C".	*/
 #define DST_S_C_CXX		 15	/* Language == "C++".	*/
+#define DST_S_C_EPILOG		127
 #define DST_S_C_VERSION		153
 #define	DST_S_C_SOURCE		155	/* Source file.		*/
 #define DST_S_C_PROLOG		162
@@ -269,15 +303,19 @@
 #define	DST_S_C_MODEND		189	/* End of module.	*/
 #define	DST_S_C_RTNBEG		190	/* Beginning of routine.*/
 #define	DST_S_C_RTNEND		191	/* End of routine.	*/
-#define	DST_S_C_DELTA_PC_W	1	/* Incr PC.		*/
-#define	DST_S_C_INCR_LINUM	2	/* Incr Line #. 	*/
-#define	DST_S_C_INCR_LINUM_W	3	/* Incr Line #. 	*/
-#define DST_S_C_SET_LINUM_INCR	4
+
+/* These are used with DST_S_C_LINE_NUM.  */
+#define DST_S_C_LINE_NUM_HEADER_SIZE 4
+
+#define DST_S_C_DELTA_PC_W	 1	/* Incr PC.		*/
+#define DST_S_C_INCR_LINUM	 2	/* Incr Line #.		*/
+#define DST_S_C_INCR_LINUM_W	 3	/* Incr Line #.		*/
+#define DST_S_C_SET_LINUM_INCR	 4
 #define DST_S_C_SET_LINUM_INCR_W 5
 #define DST_S_C_RESET_LINUM_INCR 6
-#define DST_S_C_BEG_STMT_MODE	7
-#define DST_S_C_END_STMT_MODE	8
-#define	DST_S_C_SET_LINE_NUM	9	/* Set Line #.		*/
+#define DST_S_C_BEG_STMT_MODE	 7
+#define DST_S_C_END_STMT_MODE	 8
+#define DST_S_C_SET_LINE_NUM	 9	/* Set Line #.		*/
 #define DST_S_C_SET_PC		10
 #define DST_S_C_SET_PC_W	11
 #define DST_S_C_SET_PC_L	12
@@ -295,9 +333,32 @@
 #define DST_S_C_SRC_SETFILE	 2	/* Set source file.	 */
 #define DST_S_C_SRC_SETREC_L	 3	/* Set record, longword value.  */
 #define DST_S_C_SRC_SETREC_W	 4	/* Set record, word value.  */
+#define DST_S_C_SRC_SETLNUM_L	 5	/* Set line, longword value.  */
+#define DST_S_C_SRC_SETLNUM_W	 6	/* Set line, word value.  */
+#define DST_S_C_SRC_INCRLNUM_B	 7	/* Increment line.  */
 #define DST_S_C_SRC_DEFLINES_W	10	/* # of line, word counter.  */
 #define DST_S_C_SRC_DEFLINES_B	11	/* # of line, byte counter.  */
 #define DST_S_C_SRC_FORMFEED	16	/* ^L counts as a record.  */
+
+#define DST_S_B_PCLINE_UNSBYTE	 1
+#define DST_S_W_PCLINE_UNSWORD	 1
+#define DST_S_L_PCLINE_UNSLONG	 1
+
+#define DST_S_B_MODBEG_NAME	14
+#define DST_S_L_RTNBEG_ADDRESS	 5
+#define DST_S_B_RTNBEG_NAME	13
+#define DST_S_L_RTNEND_SIZE	 5
+
+/* These are used with DST_S_C_SOURCE.  */
+#define DST_S_C_SOURCE_HEADER_SIZE 4
+
+#define DST_S_B_SRC_DF_LENGTH	  1
+#define DST_S_W_SRC_DF_FILEID	  3
+#define DST_S_B_SRC_DF_FILENAME	 20
+#define DST_S_B_SRC_UNSBYTE	  1
+#define DST_S_W_SRC_UNSWORD	  1
+#define DST_S_L_SRC_UNSLONG	  1
+
 /* The following are the codes for the various data types.  Anything not on
    the list is included under 'advanced_type'.  */
 #define DBG_S_C_UCHAR		0x02
@@ -328,6 +389,7 @@
 #define DSC_K_CLASS_D		0x02	/* Dynamic string (not via malloc!).  */
 #define DSC_K_CLASS_A		0x04	/* Array.  */
 #define DSC_K_CLASS_UBS		0x0d	/* Unaligned bit string.  */
+
 /*  These are the codes that are used to generate the definitions of struct
     union and enum records.  */
 #define DBG_S_C_ENUM_ITEM		0xa4
@@ -336,7 +398,7 @@
 #define DBG_S_C_STRUCT_ITEM		DST_K_VFLAGS_BITOFFS	/* 0xff */
 #define DBG_S_C_STRUCT_START		0xab
 #define DBG_S_C_STRUCT_END		0xac
-#define DST_K_TYPSPEC			0xaf		/* Type specification.  */
+#define DST_K_TYPSPEC			0xaf	/* Type specification.  */
 /* These codes are used in the generation of the symbol definition records.  */
 #define DST_K_VFLAGS_NOVAL		0x80	/* Struct definition only.  */
 #define DST_K_VFLAGS_DSC		0xfa	/* Descriptor used.  */
@@ -379,7 +441,7 @@
 #define DBG_S_C_VOID			DST_K_TS_PTR
 #define DBG_S_C_COMPLEX_ARRAY		DST_K_TS_ARRAY
 
-/* VMS Module header record (EMH) definitions.  */
+/* VMS Module Header Records (MHD/EMH).  */
 
 #define MHD_S_C_MHD 0
 #define MHD_S_C_LNM 1
@@ -402,48 +464,68 @@
 /* vms.c.  */
 
 extern asymbol *_bfd_vms_make_empty_symbol (bfd *);
+extern int _bfd_vms_slurp_object_records (bfd *abfd);
 
 /* vms-gsd.c.  */
 
-extern int _bfd_vms_slurp_gsd (bfd *, int);
-extern int _bfd_vms_write_gsd (bfd *, int);
+extern int _bfd_vms_slurp_gsd (bfd *abfd, int objtype);
+extern int _bfd_vms_write_gsd (bfd *abfd, int objtype);
+extern int _bfd_vms_slurp_dbg (bfd *abfd, int objtype);
+extern int _bfd_vms_write_dbg (bfd *abfd, int objtype);
+extern int _bfd_vms_slurp_tbt (bfd *abfd, int objtype);
+extern int _bfd_vms_write_tbt (bfd *abfd, int objtype);
 
-/* vms-mhd.c.  */
+/* vms-misc.c.  */
 
-extern int _bfd_vms_slurp_hdr (bfd *, int);
-extern int _bfd_vms_write_hdr (bfd *, int);
-extern int _bfd_vms_slurp_eom (bfd *, int);
-extern int _bfd_vms_write_eom (bfd *, int);
+extern int _bfd_vms_get_object_record (bfd *abfd);
+extern int _bfd_vms_get_first_record (bfd *abfd);
+
+/* vms-hdr.c.  */
+
+extern int _bfd_vms_slurp_hdr (bfd *abfd, int objtype);
+extern int _bfd_vms_write_hdr (bfd *abfd, int objtype);
+extern int _bfd_vms_slurp_eom (bfd *abfd, int objtype);
+extern int _bfd_vms_write_eom (bfd *abfd, int objtype);
+extern bfd_boolean _bfd_vms_find_nearest_dst_line
+  (bfd *abfd, asection *section, asymbol **symbols, bfd_vma offset,
+	   const char **file, const char **func, unsigned int *line);
+extern int _bfd_vms_slurp_ihd
+  (bfd *abfd, unsigned int *isd_offset, unsigned int *ihs_offset);
+extern int _bfd_vms_slurp_isd (bfd *abfd, unsigned int offset);
+extern int _bfd_vms_slurp_ihs (bfd *abfd, unsigned int offset);
 
 /* vms-tir.c.  */
 
-extern int _bfd_vms_slurp_tir (bfd *, int);
-extern int _bfd_vms_slurp_dbg (bfd *, int);
-extern int _bfd_vms_slurp_tbt (bfd *, int);
-extern int _bfd_vms_slurp_lnk (bfd *, int);
-				    	 
-extern int _bfd_vms_write_tir (bfd *, int);
-extern int _bfd_vms_write_tbt (bfd *, int);
-extern int _bfd_vms_write_dbg (bfd *, int);
-					 
-/* The r_type field in a reloc is one of he following values.  */
-#define ALPHA_R_IGNORE		0	 
-#define ALPHA_R_REFQUAD		1	 
-#define ALPHA_R_BRADDR		2	 
-#define ALPHA_R_HINT		3	 
-#define ALPHA_R_SREL16		4	 
-#define ALPHA_R_SREL32		5	 
-#define ALPHA_R_SREL64		6	 
-#define ALPHA_R_OP_PUSH		7	 
-#define ALPHA_R_OP_STORE	8	 
-#define ALPHA_R_OP_PSUB		9	 
-#define ALPHA_R_OP_PRSHIFT	10	 
-#define ALPHA_R_LINKAGE		11	 
-#define ALPHA_R_REFLONG		12	 
-#define ALPHA_R_CODEADDR	13	 
-					 
-/* Object language definitions.  */	 
-					 
+extern int _bfd_vms_slurp_tir (bfd *abfd, int objtype);
+extern int _bfd_vms_write_tir (bfd *abfd, int objtype);
+extern int _bfd_vms_slurp_lnk (bfd *abfd, int objtype);
+
+extern int _bfd_vms_slurp_relocs (bfd *abfd);
+extern int _bfd_vms_decode_relocs
+  (bfd *abfd, arelent *relocs, asection *section, asymbol **symbols);
+
+/* The r_type field in a reloc is one of the following values.  */
+#define ALPHA_R_IGNORE		0
+#define ALPHA_R_REFQUAD		1
+#define ALPHA_R_BRADDR		2
+#define ALPHA_R_HINT		3
+#define ALPHA_R_SREL16		4
+#define ALPHA_R_SREL32		5
+#define ALPHA_R_SREL64		6
+#define ALPHA_R_OP_PUSH		7
+#define ALPHA_R_OP_STORE	8
+#define ALPHA_R_OP_PSUB		9
+#define ALPHA_R_OP_PRSHIFT	10
+#define ALPHA_R_LINKAGE		11
+#define ALPHA_R_REFLONG		12
+#define ALPHA_R_CODEADDR	13
+#define ALPHA_R_NOP		14
+#define ALPHA_R_BSR		15
+#define ALPHA_R_LDA		16
+#define ALPHA_R_BOH		17
+
+/* VMS Object Language (OBJ/EOBJ).  */
+
 #define OBJ_S_C_HDR 0		/* VAX moule header record.		*/
 #define OBJ_S_C_GSD 1		/* VAX glbal symbol definition record.	*/
 #define OBJ_S_C_TIR 2		/* VAX tet information record.		*/
@@ -453,13 +535,15 @@ extern int _bfd_vms_write_dbg (bfd *, int);
 #define OBJ_S_C_LNK 6		/* VAX liker options record.		*/
 #define OBJ_S_C_EOMW 7		/* VAX en of module word-psect record.	*/
 #define OBJ_S_C_MAXRECTYP 7	/* VAX Lat assigned record type.	*/
+
 #define EOBJ_S_C_EMH 8		/* EVAX mdule header record.		*/
 #define EOBJ_S_C_EEOM 9		/* EVAX ed of module record.		*/
-#define EOBJ_S_C_EGSD 10	/* EVAX gobal symbol definition record.*/
-#define EOBJ_S_C_ETIR 11	/* EVAX txt information record.	*/
+#define EOBJ_S_C_EGSD 10	/* EVAX gobal symbol definition record. */
+#define EOBJ_S_C_ETIR 11	/* EVAX txt information record.		*/
 #define EOBJ_S_C_EDBG 12	/* EVAX Dbugger information record.	*/
 #define EOBJ_S_C_ETBT 13	/* EVAX Taceback information record.	*/
 #define EOBJ_S_C_MAXRECTYP 13	/* EVAX Lst assigned record type.	*/
+
 #define OBJ_S_K_SUBTYP 1		 
 #define OBJ_S_C_SUBTYP 1		 
 #define EOBJ_S_K_SUBTYP 4		 
@@ -475,8 +559,9 @@ extern int _bfd_vms_write_dbg (bfd *, int);
 #define EOBJ_S_C_STOREPLIM -1	/* Maximu repeat count on store commands.  */
 #define OBJ_S_C_PSCALILIM 9	/* Maximu p-sect alignment.            */
 #define EOBJ_S_C_PSCALILIM 16	/* Maximu p-sect alignment.            */
-					 
+
 #define EVAX_OFFSET	256	/* Type ofset for EVAX codes in switch.  */
+
 /* Miscellaneous definitions.  */	 
 
 #if __GNUC__				 
@@ -484,140 +569,286 @@ typedef unsigned long long uquad;
 #else					 
 typedef unsigned long uquad;		 
 #endif					 
-					 
-#define MAX_OUTREC_SIZE 4096		 
-#define MIN_OUTREC_LUFT 64		 
-					 
-typedef struct _vms_section		 
-{					 
-  unsigned char *contents;		 
-  bfd_vma offset;			 
-  bfd_size_type size;			 
-  struct _vms_section *next;		 
-} vms_section;				 
-					 
-extern vms_section * _bfd_get_vms_section (bfd *, int);
-					 
-typedef struct _vms_reloc		 
-{					 
-  struct _vms_reloc *next;		 
-  arelent *reloc;			 
-  asection *section;			 
-} vms_reloc;				 
-					 
+
+#define MAX_OUTREC_SIZE 4096
+#define MIN_OUTREC_LUFT 64
+
 /* VMS module header.  */		 
-					 
-struct hdr_struc			 
-{					 
-  int    hdr_b_strlvl;			 
-  long   hdr_l_arch1;			 
-  long   hdr_l_arch2;			 
-  long   hdr_l_recsiz;			 
-  char * hdr_t_name;			 
-  char * hdr_t_version;			 
-  char * hdr_t_date;			 
-  char * hdr_c_lnm;			 
-  char * hdr_c_src;			 
-  char * hdr_c_ttl;			 
-};					 
-					 
-/* VMS end of module.  */		 
-					 
-struct eom_struc			 
-{					 
-  long          eom_l_total_lps;	 
-  unsigned char eom_b_comcod;		 
-  bfd_boolean   eom_has_transfer;	 
-  unsigned char eom_b_tfrflg;		 
-  long          eom_l_psindx;		 
-  long          eom_l_tfradr;		 
-};					 
-					 
-enum file_format_enum { FF_UNKNOWN, FF_FOREIGN, FF_NATIVE, FF_VAX };
-					 
-typedef struct vms_symbol_struct	 
-{					 
-  struct bfd_hash_entry bfd_hash;	 
-  asymbol *symbol;			 
-} vms_symbol_entry;			 
-					 
+
+struct hdr_struct
+{
+  char hdr_b_strlvl;
+  int hdr_l_arch1;
+  int hdr_l_arch2;
+  int hdr_l_recsiz;
+  char *hdr_t_name;
+  char *hdr_t_version;
+  char *hdr_t_date;
+  char *hdr_c_lnm;
+  char *hdr_c_src;
+  char *hdr_c_ttl;
+  char *hdr_c_cpr;
+};
+
+#define EMH_S_W_HDRTYP   4
+#define EMH_S_B_STRLVL   6
+#define EMH_S_L_ARCH1    8
+#define EMH_S_L_ARCH2   12
+#define EH_S_L_RECSIZ  16
+#define EMH_S_B_NAMLNG  20
+
+#define EMH_DATE_LENGTH  17
+
+/* VMS End-Of-Module records (EOM/EEOM).  */
+
+struct eom_struct
+{
+  int eom_l_total_lps;
+  short eom_w_comcod;
+  bfd_boolean eom_has_transfer;
+  char eom_b_tfrflg;
+  int eom_l_psindx;
+  int eom_l_tfradr;
+};
+
+#define EEOM_S_L_TOTAL_LPS   4
+#define EEOM_S_W_COMCOD      8
+#define EEOM_S_B_TFRFLG     10
+#define EEOM_S_L_PSINDX     12
+#define EEOM_S_L_TFRADR     16
+
+/* VMS Image Header Records (IHD/EIHD).  */
+
+#define EIHD_S_K_MAJORID	3	/* Major id constant	*/
+#define EIHD_S_K_MINORID	0	/* Minor id constant	*/
+#define EIHD_S_K_EXE		1	/* Executable image	*/
+
+#define EIHD_S_L_SIZE		8
+#define EIHD_S_L_ISDOFF		12
+#define EIHD_S_L_SYMDBGOFF	20
+#define EIHD_S_Q_SYMVVA		40
+#define EIHD_S_L_IMGTYPE	52
+
+/* VMS Image Section Description Records (ISD/EISD).  */
+
+#define EISD_S_L_EISDSIZE	 8
+#define EISD_S_L_SECSIZE	12
+#define EISD_S_Q_VIR_ADDR	16
+#define EISD_S_L_FLAGS		24
+#define EISD_S_L_VBN		28
+#define EISD_S_R_CONTROL	32
+#define EISD_S_L_IDENT		36
+#define EISD_S_T_GBLNAM		40
+
+#define EISD_S_M_GBL		0x0001
+#define EISD_S_M_CRF		0x0002
+#define EISD_S_M_DZRO		0x0004
+#define EISD_S_M_WRT		0x0008
+#define EISD_S_M_INITALCODE	0x0010
+#define EISD_S_M_BASED		0x0020
+#define EISD_S_M_FIXUPVEC	0x0040
+#define EISD_S_M_RESIDENT	0x0080
+#define EISD_S_M_VECTOR		0x0100
+#define EISD_S_M_PROTECT	0x0200
+#define EISD_S_M_LASTCLU	0x0400
+#define EISD_S_M_EXE		0x0800
+#define EISD_S_M_NONSHRADR	0x1000
+#define EISD_S_M_QUAD_LENGTH	0x2000
+#define EISD_S_M_ALLOC_64BIT	0x4000
+
+/* VMS Image Header Symbol Records (IHS/EIHS).  */
+
+#define EIHS_S_L_DSTVBN		 8
+#define EIHS_S_L_DSTSIZE	12
+#define EIHS_S_L_GSTVBN		16
+#define EIHS_S_L_GSTSIZE	20
+#define EIHS_S_L_DMTVBN		24
+#define EIHS_S_L_DMTBYTES	28
+
+/* Debugger symbol definitions.  */
+
+#define DBG_S_L_DMT_MODBEG       0
+#define DBG_S_L_DST_SIZE         4
+#define DBG_S_W_DMT_PSECT_COUNT  8
+#define DBG_S_C_DMT_HEADER_SIZE 12
+
+#define DBG_S_L_DMT_PSECT_START  0
+#define DBG_S_L_DMT_PSECT_LENGTH 4
+#define DBG_S_C_DMT_PSECT_SIZE   8
+
+
+enum file_format_enum { FF_UNKNOWN, FF_FOREIGN, FF_NATIVE };
+enum file_type_enum { FT_UNKNOWN, FT_MODULE, FT_IMAGE };
+
+typedef struct vms_symbol_struct
+{
+  struct bfd_hash_entry bfd_hash;
+  asymbol *symbol;
+} vms_symbol_entry;
+
 /* Stack value for push/pop commands.  */
-					 
-struct stack_struct			 
-{					 
-  uquad value;				 
-  int psect;				 
-};					 
-#define STACKSIZE 8192			 
-					 
-/* location stack definitions for CTL_DFLC, CTL_STLOC, and CTL_STKDL  */
-					 
-struct location_struct			 
-{					 
-  unsigned long value;			 
-  int psect;				 
-};					 
-#define LOCATION_SAVE_SIZE 32		 
-					 
-#define VMS_SECTION_COUNT 1024		 
-					 
-struct vms_private_data_struct		 
-{					 
-  bfd_boolean is_vax;				 
+
+struct stack_struct
+{
+  uquad value;
+  int psect;
+};
+
+#define STACKSIZE 8192
+
+/* A minimal decoding of DST compilation units.  We only decode
+   what's needed to get to the line number information.  */
+
+struct fileinfo
+{
+  char *name;
+  unsigned int srec;
+};
+
+struct srecinfo
+{
+  struct srecinfo *next;
+  unsigned int line;
+  unsigned int sfile;
+  unsigned int srec;
+};
+
+struct lineinfo
+{
+  struct lineinfo *next;
+  bfd_vma address;
+  unsigned int line;
+};
+
+struct funcinfo
+{
+  struct funcinfo *next;
+  char *name;
+  bfd_vma low;
+  bfd_vma high;
+};
+
+struct module
+{
+  /* Chain the previously read compilation unit.  */
+  struct module *next;
+
+  /* The module name.  */
+  char *name;
+
+  /* The start offset and size of debug info in the DST section.  */
+  unsigned int modbeg;
+  unsigned int size;
+
+  /* The lowest and highest addresses contained in this compilation
+     unit as specified in the compilation unit header.  */
+  bfd_vma low;
+  bfd_vma high;
+
+  /* The listing line table.  */
+  struct lineinfo *line_table;
+
+  /* The source record table.  */
+  struct srecinfo *srec_table;
+
+  /* A list of the functions found in this module.  */
+  struct funcinfo *func_table;
+
+  /* Current allocation of file_table.  */
+  unsigned int file_table_count;
+
+  /* An array of the files making up this module.  */
+  struct fileinfo *file_table;
+};
+
+struct vms_private_data_struct
+{
+  bfd_boolean is_vax;
   bfd_boolean fixup_done;		/* Flag to indicate if all
 					   section pointers and PRIV(sections)
 					   are set up correctly.  */
-  unsigned char *vms_buf;		/* Buffer to record.  */
-  int buf_size;				/* Max size of buffer.  */
-  unsigned char *vms_rec;		/* Actual record ptr.  */
-  int rec_length;			/* Remaining record length.  */
-  int rec_size;				/* Actual record size.  */
-  int rec_type;				/* Actual record type.  */
-  enum file_format_enum file_format;	 
-					 
-  struct hdr_struc hdr_data;		/* Data from HDR/EMH record.  */
-  struct eom_struc eom_data;		/* Data from EOM/EEOM record.  */
-  unsigned int section_count;		/* # of sections in following array.  */
-  asection **sections;			/* Array of GSD/EGSD sections.  */
-  int gsd_sym_count;			/* # of GSD/EGSD symbols.  */
-  asymbol **symbols;			/* Vector of GSD/EGSD symbols.  */
-  struct proc_value *procedure;		 
-					 
-  struct stack_struct *stack;		 
-  int stackptr;				 
-					 
-  vms_section *vms_section_table[VMS_SECTION_COUNT];
-					 
+  unsigned char *vms_buf;		/* record buffer */
+  unsigned int buf_size;		/* size of record buffer  */
+  unsigned char *vms_rec;		/* record pointer in record buffer */
+  unsigned int rec_size;		/* record size  */
+  enum file_format_enum file_format;
+
+  struct hdr_struct hdr_data;		/* data from HDR/EMH record  */
+  struct eom_struct eom_data;		/* data from EOM/EEOM record  */
+  unsigned int section_count;		/* # of sections in following array  */
+  asection **sections;			/* array of GSD/EGSD sections  */
+  unsigned int gsd_sym_count;		/* # of GSD/EGSD symbols  */
+  asymbol **symbols;			/* vector of GSD/EGSD symbols  */
+  struct proc_value *procedure;
+
+  struct stack_struct *stack;
+  int stackptr;
+
   struct bfd_hash_table *vms_symbol_table;
-  struct bfd_symbol **symcache;		 
-  int symnum;				 
-					 
-  struct location_struct *location_stack;
-					 
-  asection *image_section;		/* Section for image_ptr.  */
-  unsigned char *image_ptr;		/* A pointer to section->contents.  */
-					 
-  unsigned char pdsc[8];		/* Procedure descriptor.  */
-					 
-  /* Output routine storage.  */	 
-  unsigned char *output_buf;		/* Output data.  */
-  int push_level;			 
-  int pushed_size;			 
-  int length_pos;			 
-  int output_size;			 
-  int output_alignment;			 
-					 
-  /* Linkage index counter		 
-     used by conditional store commands (TIR_S_C_STC_).   */
-  int vms_linkage_index;		 
-					 
-  /* see tc-alpha.c of gas for a descripton.  */
-  int flag_hash_long_names;	/* -+, hash instead of truncate.  */
-  int flag_show_after_trunc;	/* -H, shw hashing/truncation.  */
-};					 
-					 
-#define PRIV(name)	((struct vms_private_data_struct *) abfd->tdata.any)->name
-					 
+  struct bfd_symbol **symcache;
+  int symnum;
+
+  asection *image_section;		/* section for image_ptr  */
+  unsigned char *image_ptr;		/* a pointer to section->contents */
+
+  unsigned char pdsc[8];		/* procedure descriptor */
+
+  struct module *modules;		/* list of all compilation units */
+
+  struct dst_info *dst_info;
+  asection *dst_section;
+  unsigned char *dst_ptr_end;
+  unsigned int dst_ptr_offsets_count;	/* # of offsets in following array  */
+  unsigned int *dst_ptr_offsets;	/* array of saved image_ptr offsets */
+
+  /* Shared library support */
+  bfd_vma symvva; /* relative virtual address of symbol vector */
+
+  /* Output routine storage  */
+  unsigned char *output_buf;		/* output data  */
+  int push_level;
+  int pushed_size;
+  int length_pos;
+  int output_size;
+  int output_alignment;
+
+  /* linkage index counter used by conditional store commands */
+  int vms_linkage_index;
+
+  /* see tc-alpha.c of gas for a description.  */
+  int flag_hash_long_names;	/* -+, hash instead of truncate */
+  int flag_show_after_trunc;	/* -H, show hashing/truncation */
+};
+
+#define PRIV(name) ((struct vms_private_data_struct *)abfd->tdata.any)->name
+
+/* Used to keep extra VMS specific information for a given section.
+
+   reloc_size holds the size of the relocation stream, note this
+   is very different from the number of relocations as VMS relocations
+   are variable length.
+
+   reloc_stream is the actual stream of relocation entries.  */
+
+struct vms_section_data_struct
+{
+  bfd_size_type reloc_size;
+  unsigned char *reloc_stream;
+  bfd_size_type reloc_offset;
+  flagword vflags;
+};
+
+#define vms_section_data(sec) \
+  ((struct vms_section_data_struct *)sec->used_by_bfd)
+ 
+struct evax_private_udata_struct
+{
+  asymbol *bsym;
+  asymbol *enbsym;
+  char *origname;
+  int lkindex;
+};
+
 #define SECTION_NAME_TEMPLATE "__SEC__%d"
 					 
 #if VMS_DEBUG				 
@@ -635,7 +866,6 @@ extern char *      _bfd_vms_save_sized_string (unsigned char *, int);
 extern char *      _bfd_vms_save_counted_string (unsigned char *);
 extern void        _bfd_vms_push (bfd *, uquad, int);
 extern uquad       _bfd_vms_pop (bfd *, int *);
-extern bfd_boolean _bfd_save_vms_section (bfd *, asection *, const void *, file_ptr, bfd_size_type);
 extern void        _bfd_vms_output_begin (bfd *, int, int);
 extern void        _bfd_vms_output_alignment (bfd *, int);
 extern void        _bfd_vms_output_push (bfd *);
@@ -653,4 +883,7 @@ extern void        _bfd_vms_output_fill (bfd *, int, int);
 extern char *      _bfd_vms_length_hash_symbol (bfd *, const char *, int);
 extern vms_symbol_entry * _bfd_vms_enter_symbol (bfd *, char *);
 
+#define EGPS_S_V_NO_SHIFT 16
+
+extern void        bfd_vms_set_section_flags (bfd *, asection *, flagword);
 #endif /* VMS_H */