2012-03-27 23:13:14 +00:00
|
|
|
|
/* Output VMS debug format symbol table information from GCC.
|
2022-10-27 18:55:19 +00:00
|
|
|
|
Copyright (C) 1987-2022 Free Software Foundation, Inc.
|
2012-03-27 23:13:14 +00:00
|
|
|
|
Contributed by Douglas B. Rupp (rupp@gnat.com).
|
|
|
|
|
Updated by Bernard W. Giroud (bgiroud@users.sourceforge.net).
|
|
|
|
|
|
|
|
|
|
This file is part of GCC.
|
|
|
|
|
|
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
|
|
|
the terms of the GNU General Public License as published by the Free
|
|
|
|
|
Software Foundation; either version 3, or (at your option) any later
|
|
|
|
|
version.
|
|
|
|
|
|
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
|
for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with GCC; see the file COPYING3. If not see
|
|
|
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
#include "system.h"
|
|
|
|
|
#include "coretypes.h"
|
|
|
|
|
#include "tm.h"
|
|
|
|
|
|
|
|
|
|
#ifdef VMS_DEBUGGING_INFO
|
2015-08-28 15:33:40 +00:00
|
|
|
|
#include "alias.h"
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#include "tree.h"
|
2014-09-21 17:33:12 +00:00
|
|
|
|
#include "varasm.h"
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#include "version.h"
|
|
|
|
|
#include "flags.h"
|
|
|
|
|
#include "rtl.h"
|
|
|
|
|
#include "output.h"
|
|
|
|
|
#include "vmsdbg.h"
|
|
|
|
|
#include "debug.h"
|
|
|
|
|
#include "langhooks.h"
|
|
|
|
|
#include "function.h"
|
|
|
|
|
#include "target.h"
|
2018-12-28 15:30:48 +00:00
|
|
|
|
#include "file-prefix-map.h" /* remap_debug_filename() */
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
/* Difference in seconds between the VMS Epoch and the Unix Epoch */
|
|
|
|
|
static const long long vms_epoch_offset = 3506716800ll;
|
|
|
|
|
|
|
|
|
|
int vms_file_stats_name (const char *, long long *, long *, char *, int *);
|
|
|
|
|
|
|
|
|
|
/* NOTE: In the comments in this file, many references are made to "Debug
|
|
|
|
|
Symbol Table". This term is abbreviated as `DST' throughout the remainder
|
|
|
|
|
of this file. */
|
|
|
|
|
|
|
|
|
|
typedef struct dst_line_info_struct *dst_line_info_ref;
|
|
|
|
|
|
|
|
|
|
/* Each entry in the line_info_table maintains the file and
|
|
|
|
|
line number associated with the label generated for that
|
|
|
|
|
entry. The label gives the PC value associated with
|
|
|
|
|
the line number entry. */
|
|
|
|
|
typedef struct dst_line_info_struct
|
|
|
|
|
{
|
|
|
|
|
unsigned long dst_file_num;
|
|
|
|
|
unsigned long dst_line_num;
|
|
|
|
|
}
|
|
|
|
|
dst_line_info_entry;
|
|
|
|
|
|
|
|
|
|
typedef struct dst_file_info_struct *dst_file_info_ref;
|
|
|
|
|
|
|
|
|
|
typedef struct dst_file_info_struct
|
|
|
|
|
{
|
|
|
|
|
char *file_name;
|
|
|
|
|
unsigned int max_line;
|
|
|
|
|
unsigned int listing_line_start;
|
|
|
|
|
long long cdt;
|
|
|
|
|
long ebk;
|
|
|
|
|
short ffb;
|
|
|
|
|
char rfo;
|
|
|
|
|
}
|
|
|
|
|
dst_file_info_entry;
|
|
|
|
|
|
|
|
|
|
/* Maximum size (in bytes) of an artificially generated label. */
|
|
|
|
|
#define MAX_ARTIFICIAL_LABEL_BYTES 30
|
|
|
|
|
|
|
|
|
|
/* Make sure we know the sizes of the various types debug can describe. These
|
|
|
|
|
are only defaults. If the sizes are different for your target, you should
|
|
|
|
|
override these values by defining the appropriate symbols in your tm.h
|
|
|
|
|
file. */
|
|
|
|
|
#ifndef PTR_SIZE
|
|
|
|
|
#define PTR_SIZE 4 /* Must be 32 bits for VMS debug info */
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Pointer to a structure of filenames referenced by this compilation unit. */
|
|
|
|
|
static dst_file_info_ref file_info_table;
|
|
|
|
|
|
|
|
|
|
/* Total number of entries in the table (i.e. array) pointed to by
|
|
|
|
|
`file_info_table'. This is the *total* and includes both used and unused
|
|
|
|
|
slots. */
|
|
|
|
|
static unsigned int file_info_table_allocated;
|
|
|
|
|
|
|
|
|
|
/* Number of entries in the file_info_table which are actually in use. */
|
|
|
|
|
static unsigned int file_info_table_in_use;
|
|
|
|
|
|
|
|
|
|
/* Size (in elements) of increments by which we may expand the filename
|
|
|
|
|
table. */
|
|
|
|
|
#define FILE_TABLE_INCREMENT 64
|
|
|
|
|
|
|
|
|
|
typedef char *char_p;
|
|
|
|
|
|
2014-09-21 17:33:12 +00:00
|
|
|
|
static vec<char_p> funcnam_table;
|
|
|
|
|
static vec<unsigned> funcnum_table;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#define FUNC_TABLE_INITIAL 256
|
|
|
|
|
|
|
|
|
|
/* Local pointer to the name of the main input file. Initialized in
|
|
|
|
|
vmsdbgout_init. */
|
|
|
|
|
static const char *primary_filename;
|
|
|
|
|
|
|
|
|
|
static char *module_producer;
|
|
|
|
|
static unsigned int module_language;
|
|
|
|
|
|
|
|
|
|
/* A pointer to the base of a table that contains line information
|
|
|
|
|
for each source code line in .text in the compilation unit. */
|
|
|
|
|
static dst_line_info_ref line_info_table;
|
|
|
|
|
|
|
|
|
|
/* Number of elements currently allocated for line_info_table. */
|
|
|
|
|
static unsigned int line_info_table_allocated;
|
|
|
|
|
|
|
|
|
|
/* Number of elements in line_info_table currently in use. */
|
|
|
|
|
static unsigned int line_info_table_in_use;
|
|
|
|
|
|
|
|
|
|
/* Size (in elements) of increments by which we may expand line_info_table. */
|
|
|
|
|
#define LINE_INFO_TABLE_INCREMENT 1024
|
|
|
|
|
|
|
|
|
|
/* Forward declarations for functions defined in this file. */
|
|
|
|
|
static char *full_name (const char *);
|
|
|
|
|
static unsigned int lookup_filename (const char *);
|
|
|
|
|
static int write_debug_header (DST_HEADER *, const char *, int);
|
|
|
|
|
static int write_debug_addr (const char *, const char *, int);
|
|
|
|
|
static int write_debug_data1 (unsigned int, const char *, int);
|
|
|
|
|
static int write_debug_data2 (unsigned int, const char *, int);
|
|
|
|
|
static int write_debug_data4 (unsigned long, const char *, int);
|
|
|
|
|
static int write_debug_data8 (unsigned long long, const char *, int);
|
|
|
|
|
static int write_debug_delta4 (const char *, const char *, const char *, int);
|
|
|
|
|
static int write_debug_string (const char *, const char *, int);
|
|
|
|
|
static int write_modbeg (int);
|
|
|
|
|
static int write_modend (int);
|
|
|
|
|
static int write_rtnbeg (int, int);
|
|
|
|
|
static int write_rtnend (int, int);
|
|
|
|
|
static int write_pclines (int);
|
|
|
|
|
static int write_srccorr (int, dst_file_info_entry, int);
|
|
|
|
|
static int write_srccorrs (int);
|
|
|
|
|
|
|
|
|
|
static void vmsdbgout_init (const char *);
|
|
|
|
|
static void vmsdbgout_finish (const char *);
|
2018-12-28 15:30:48 +00:00
|
|
|
|
static void vmsdbgout_early_finish (const char *);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
static void vmsdbgout_assembly_start (void);
|
|
|
|
|
static void vmsdbgout_define (unsigned int, const char *);
|
|
|
|
|
static void vmsdbgout_undef (unsigned int, const char *);
|
|
|
|
|
static void vmsdbgout_start_source_file (unsigned int, const char *);
|
|
|
|
|
static void vmsdbgout_end_source_file (unsigned int);
|
|
|
|
|
static void vmsdbgout_begin_block (unsigned int, unsigned int);
|
|
|
|
|
static void vmsdbgout_end_block (unsigned int, unsigned int);
|
|
|
|
|
static bool vmsdbgout_ignore_block (const_tree);
|
2017-10-07 00:16:47 +00:00
|
|
|
|
static void vmsdbgout_source_line (unsigned int, unsigned int, const char *,
|
|
|
|
|
int, bool);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
static void vmsdbgout_write_source_line (unsigned, const char *, int , bool);
|
2017-10-07 00:16:47 +00:00
|
|
|
|
static void vmsdbgout_begin_prologue (unsigned int, unsigned int,
|
|
|
|
|
const char *);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
static void vmsdbgout_end_prologue (unsigned int, const char *);
|
|
|
|
|
static void vmsdbgout_end_function (unsigned int);
|
|
|
|
|
static void vmsdbgout_begin_epilogue (unsigned int, const char *);
|
|
|
|
|
static void vmsdbgout_end_epilogue (unsigned int, const char *);
|
|
|
|
|
static void vmsdbgout_begin_function (tree);
|
2017-04-10 11:32:00 +00:00
|
|
|
|
static void vmsdbgout_function_decl (tree);
|
|
|
|
|
static void vmsdbgout_early_global_decl (tree);
|
|
|
|
|
static void vmsdbgout_late_global_decl (tree);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
static void vmsdbgout_type_decl (tree, int);
|
|
|
|
|
static void vmsdbgout_abstract_function (tree);
|
|
|
|
|
|
|
|
|
|
/* The debug hooks structure. */
|
|
|
|
|
|
|
|
|
|
const struct gcc_debug_hooks vmsdbg_debug_hooks
|
|
|
|
|
= {vmsdbgout_init,
|
|
|
|
|
vmsdbgout_finish,
|
2018-12-28 15:30:48 +00:00
|
|
|
|
vmsdbgout_early_finish,
|
2012-03-27 23:13:14 +00:00
|
|
|
|
vmsdbgout_assembly_start,
|
|
|
|
|
vmsdbgout_define,
|
|
|
|
|
vmsdbgout_undef,
|
|
|
|
|
vmsdbgout_start_source_file,
|
|
|
|
|
vmsdbgout_end_source_file,
|
|
|
|
|
vmsdbgout_begin_block,
|
|
|
|
|
vmsdbgout_end_block,
|
|
|
|
|
vmsdbgout_ignore_block,
|
|
|
|
|
vmsdbgout_source_line,
|
2022-10-27 18:55:19 +00:00
|
|
|
|
debug_nothing_int_int_charstar, /* set_ignored_loc */
|
2012-03-27 23:13:14 +00:00
|
|
|
|
vmsdbgout_begin_prologue,
|
|
|
|
|
vmsdbgout_end_prologue,
|
|
|
|
|
vmsdbgout_begin_epilogue,
|
|
|
|
|
vmsdbgout_end_epilogue,
|
|
|
|
|
vmsdbgout_begin_function,
|
|
|
|
|
vmsdbgout_end_function,
|
2015-08-28 15:33:40 +00:00
|
|
|
|
debug_nothing_tree, /* register_main_translation_unit */
|
2017-04-10 11:32:00 +00:00
|
|
|
|
vmsdbgout_function_decl,
|
|
|
|
|
vmsdbgout_early_global_decl,
|
|
|
|
|
vmsdbgout_late_global_decl,
|
2012-03-27 23:13:14 +00:00
|
|
|
|
vmsdbgout_type_decl, /* type_decl */
|
2018-12-28 15:30:48 +00:00
|
|
|
|
debug_nothing_tree_tree_tree_bool_bool, /* imported_module_or_decl */
|
|
|
|
|
debug_false_tree_charstarstar_uhwistar, /* die_ref_for_decl */
|
|
|
|
|
debug_nothing_tree_charstar_uhwi, /* register_external_die */
|
2012-03-27 23:13:14 +00:00
|
|
|
|
debug_nothing_tree, /* deferred_inline_function */
|
|
|
|
|
vmsdbgout_abstract_function,
|
2015-08-28 15:33:40 +00:00
|
|
|
|
debug_nothing_rtx_code_label, /* label */
|
2012-03-27 23:13:14 +00:00
|
|
|
|
debug_nothing_int, /* handle_pch */
|
2015-08-28 15:33:40 +00:00
|
|
|
|
debug_nothing_rtx_insn, /* var_location */
|
2018-12-28 15:30:48 +00:00
|
|
|
|
debug_nothing_tree, /* inline_entry */
|
2017-04-10 11:32:00 +00:00
|
|
|
|
debug_nothing_tree, /* size_function */
|
2012-03-27 23:13:14 +00:00
|
|
|
|
debug_nothing_void, /* switch_text_section */
|
|
|
|
|
debug_nothing_tree_tree, /* set_name */
|
|
|
|
|
0, /* start_end_main_source_file */
|
|
|
|
|
TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Definitions of defaults for assembler-dependent names of various
|
2014-09-21 17:33:12 +00:00
|
|
|
|
pseudo-ops and section names. */
|
|
|
|
|
#define VMS_UNALIGNED_SHORT_ASM_OP ".word"
|
|
|
|
|
#define VMS_UNALIGNED_INT_ASM_OP ".long"
|
|
|
|
|
#define VMS_UNALIGNED_LONG_ASM_OP ".long"
|
|
|
|
|
#define VMS_UNALIGNED_DOUBLE_INT_ASM_OP ".quad"
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
2014-09-21 17:33:12 +00:00
|
|
|
|
#define VMS_ASM_BYTE_OP ".byte"
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
#define NUMBYTES(I) ((I) < 256 ? 1 : (I) < 65536 ? 2 : 4)
|
|
|
|
|
|
|
|
|
|
#define NUMBYTES0(I) ((I) < 128 ? 0 : (I) < 65536 ? 2 : 4)
|
|
|
|
|
|
|
|
|
|
#ifndef UNALIGNED_PTR_ASM_OP
|
|
|
|
|
#define UNALIGNED_PTR_ASM_OP \
|
2014-09-21 17:33:12 +00:00
|
|
|
|
(PTR_SIZE == 8 ? VMS_UNALIGNED_DOUBLE_INT_ASM_OP : VMS_UNALIGNED_INT_ASM_OP)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef UNALIGNED_OFFSET_ASM_OP
|
|
|
|
|
#define UNALIGNED_OFFSET_ASM_OP(OFFSET) \
|
2014-09-21 17:33:12 +00:00
|
|
|
|
(NUMBYTES (OFFSET) == 4 \
|
|
|
|
|
? VMS_UNALIGNED_LONG_ASM_OP \
|
|
|
|
|
: (NUMBYTES (OFFSET) == 2 ? VMS_UNALIGNED_SHORT_ASM_OP : VMS_ASM_BYTE_OP))
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Definitions of defaults for formats and names of various special
|
|
|
|
|
(artificial) labels which may be generated within this file (when the -g
|
|
|
|
|
options is used and VMS_DEBUGGING_INFO is in effect. If necessary, these
|
|
|
|
|
may be overridden from within the tm.h file, but typically, overriding these
|
|
|
|
|
defaults is unnecessary. */
|
|
|
|
|
|
|
|
|
|
static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
|
|
|
|
|
|
|
|
|
|
#ifndef TEXT_END_LABEL
|
|
|
|
|
#define TEXT_END_LABEL "Lvetext"
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef FUNC_BEGIN_LABEL
|
|
|
|
|
#define FUNC_BEGIN_LABEL "LVFB"
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef FUNC_PROLOG_LABEL
|
|
|
|
|
#define FUNC_PROLOG_LABEL "LVFP"
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef FUNC_EPILOG_LABEL
|
|
|
|
|
#define FUNC_EPILOG_LABEL "LVEB"
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef FUNC_END_LABEL
|
|
|
|
|
#define FUNC_END_LABEL "LVFE"
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef BLOCK_BEGIN_LABEL
|
|
|
|
|
#define BLOCK_BEGIN_LABEL "LVBB"
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef BLOCK_END_LABEL
|
|
|
|
|
#define BLOCK_END_LABEL "LVBE"
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef LINE_CODE_LABEL
|
|
|
|
|
#define LINE_CODE_LABEL "LVM"
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_DELTA2
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_DELTA2(FILE,LABEL1,LABEL2) \
|
|
|
|
|
do \
|
|
|
|
|
{ \
|
2014-09-21 17:33:12 +00:00
|
|
|
|
fprintf ((FILE), "\t%s\t", VMS_UNALIGNED_SHORT_ASM_OP); \
|
2012-03-27 23:13:14 +00:00
|
|
|
|
assemble_name (FILE, LABEL1); \
|
|
|
|
|
fprintf (FILE, "-"); \
|
|
|
|
|
assemble_name (FILE, LABEL2); \
|
|
|
|
|
} \
|
|
|
|
|
while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_DELTA4
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_DELTA4(FILE,LABEL1,LABEL2) \
|
|
|
|
|
do \
|
|
|
|
|
{ \
|
2014-09-21 17:33:12 +00:00
|
|
|
|
fprintf ((FILE), "\t%s\t", VMS_UNALIGNED_INT_ASM_OP); \
|
2012-03-27 23:13:14 +00:00
|
|
|
|
assemble_name (FILE, LABEL1); \
|
|
|
|
|
fprintf (FILE, "-"); \
|
|
|
|
|
assemble_name (FILE, LABEL2); \
|
|
|
|
|
} \
|
|
|
|
|
while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_ADDR_DELTA
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_ADDR_DELTA(FILE,LABEL1,LABEL2) \
|
|
|
|
|
do \
|
|
|
|
|
{ \
|
|
|
|
|
fprintf ((FILE), "\t%s\t", UNALIGNED_PTR_ASM_OP); \
|
|
|
|
|
assemble_name (FILE, LABEL1); \
|
|
|
|
|
fprintf (FILE, "-"); \
|
|
|
|
|
assemble_name (FILE, LABEL2); \
|
|
|
|
|
} \
|
|
|
|
|
while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_ADDR
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_ADDR(FILE,LABEL) \
|
|
|
|
|
do \
|
|
|
|
|
{ \
|
|
|
|
|
fprintf ((FILE), "\t%s\t", UNALIGNED_PTR_ASM_OP); \
|
|
|
|
|
assemble_name (FILE, LABEL); \
|
|
|
|
|
} \
|
|
|
|
|
while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_ADDR_CONST
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_ADDR_CONST(FILE,ADDR) \
|
|
|
|
|
fprintf ((FILE), "\t%s\t%s", UNALIGNED_PTR_ASM_OP, (ADDR))
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_DATA1
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_DATA1(FILE,VALUE) \
|
2014-09-21 17:33:12 +00:00
|
|
|
|
fprintf ((FILE), "\t%s\t%#x", VMS_ASM_BYTE_OP, (unsigned char) VALUE)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_DATA2
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_DATA2(FILE,VALUE) \
|
2014-09-21 17:33:12 +00:00
|
|
|
|
fprintf ((FILE), "\t%s\t%#x", VMS_UNALIGNED_SHORT_ASM_OP, \
|
2012-03-27 23:13:14 +00:00
|
|
|
|
(unsigned short) VALUE)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_DATA4
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_DATA4(FILE,VALUE) \
|
2014-09-21 17:33:12 +00:00
|
|
|
|
fprintf ((FILE), "\t%s\t%#lx", VMS_UNALIGNED_INT_ASM_OP, \
|
|
|
|
|
(unsigned long) VALUE)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_DATA
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_DATA(FILE,VALUE) \
|
2014-09-21 17:33:12 +00:00
|
|
|
|
fprintf ((FILE), "\t%s\t%#lx", UNALIGNED_OFFSET_ASM_OP (VALUE), VALUE)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_ADDR_DATA
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_ADDR_DATA(FILE,VALUE) \
|
|
|
|
|
fprintf ((FILE), "\t%s\t%#lx", UNALIGNED_PTR_ASM_OP, \
|
|
|
|
|
(unsigned long) VALUE)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_DATA8
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_DATA8(FILE,VALUE) \
|
2014-09-21 17:33:12 +00:00
|
|
|
|
fprintf ((FILE), "\t%s\t%#llx", VMS_UNALIGNED_DOUBLE_INT_ASM_OP, \
|
2012-03-27 23:13:14 +00:00
|
|
|
|
(unsigned long long) VALUE)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
|
|
|
|
|
newline is produced. When flag_verbose_asm is asserted, we add commentary
|
|
|
|
|
at the end of the line, so we must avoid output of a newline here. */
|
|
|
|
|
#ifndef ASM_OUTPUT_DEBUG_STRING
|
|
|
|
|
#define ASM_OUTPUT_DEBUG_STRING(FILE,P) \
|
|
|
|
|
do \
|
|
|
|
|
{ \
|
2022-10-27 18:55:19 +00:00
|
|
|
|
int slen = strlen (P); \
|
|
|
|
|
const char *p = (P); \
|
|
|
|
|
int i; \
|
2012-03-27 23:13:14 +00:00
|
|
|
|
fprintf (FILE, "\t.ascii \""); \
|
|
|
|
|
for (i = 0; i < slen; i++) \
|
|
|
|
|
{ \
|
2022-10-27 18:55:19 +00:00
|
|
|
|
int c = p[i]; \
|
2012-03-27 23:13:14 +00:00
|
|
|
|
if (c == '\"' || c == '\\') \
|
|
|
|
|
putc ('\\', FILE); \
|
|
|
|
|
if (c >= ' ' && c < 0177) \
|
|
|
|
|
putc (c, FILE); \
|
|
|
|
|
else \
|
|
|
|
|
fprintf (FILE, "\\%o", c); \
|
|
|
|
|
} \
|
|
|
|
|
fprintf (FILE, "\""); \
|
|
|
|
|
} \
|
|
|
|
|
while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Convert a reference to the assembler name of a C-level name. This
|
|
|
|
|
macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
|
|
|
|
|
a string rather than writing to a file. */
|
|
|
|
|
#ifndef ASM_NAME_TO_STRING
|
|
|
|
|
#define ASM_NAME_TO_STRING(STR, NAME) \
|
|
|
|
|
do \
|
|
|
|
|
{ \
|
|
|
|
|
if ((NAME)[0] == '*') \
|
|
|
|
|
strcpy (STR, NAME+1); \
|
|
|
|
|
else \
|
|
|
|
|
strcpy (STR, NAME); \
|
|
|
|
|
} \
|
|
|
|
|
while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Output the debug header HEADER. Also output COMMENT if flag_verbose_asm is
|
|
|
|
|
set. Return the header size. Just return the size if DOSIZEONLY is
|
|
|
|
|
nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_debug_header (DST_HEADER *header, const char *comment, int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
if (!dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
ASM_OUTPUT_DEBUG_DATA2 (asm_out_file,
|
|
|
|
|
header->dst__header_length.dst_w_length);
|
|
|
|
|
|
|
|
|
|
if (flag_verbose_asm)
|
|
|
|
|
fprintf (asm_out_file, "\t%s record length", ASM_COMMENT_START);
|
|
|
|
|
fputc ('\n', asm_out_file);
|
|
|
|
|
|
|
|
|
|
ASM_OUTPUT_DEBUG_DATA2 (asm_out_file,
|
|
|
|
|
header->dst__header_type.dst_w_type);
|
|
|
|
|
|
|
|
|
|
if (flag_verbose_asm)
|
|
|
|
|
fprintf (asm_out_file, "\t%s record type (%s)", ASM_COMMENT_START,
|
|
|
|
|
comment);
|
|
|
|
|
|
|
|
|
|
fputc ('\n', asm_out_file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 4;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output the address of SYMBOL. Also output COMMENT if flag_verbose_asm is
|
|
|
|
|
set. Return the address size. Just return the size if DOSIZEONLY is
|
|
|
|
|
nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_debug_addr (const char *symbol, const char *comment, int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
if (!dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
ASM_OUTPUT_DEBUG_ADDR (asm_out_file, symbol);
|
|
|
|
|
if (flag_verbose_asm)
|
|
|
|
|
fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
|
|
|
|
|
fputc ('\n', asm_out_file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return PTR_SIZE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output the single byte DATA1. Also output COMMENT if flag_verbose_asm is
|
|
|
|
|
set. Return the data size. Just return the size if DOSIZEONLY is
|
|
|
|
|
nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_debug_data1 (unsigned int data1, const char *comment, int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
if (!dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
ASM_OUTPUT_DEBUG_DATA1 (asm_out_file, data1);
|
|
|
|
|
if (flag_verbose_asm)
|
|
|
|
|
fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
|
|
|
|
|
fputc ('\n', asm_out_file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output the single word DATA2. Also output COMMENT if flag_verbose_asm is
|
|
|
|
|
set. Return the data size. Just return the size if DOSIZEONLY is
|
|
|
|
|
nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_debug_data2 (unsigned int data2, const char *comment, int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
if (!dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
ASM_OUTPUT_DEBUG_DATA2 (asm_out_file, data2);
|
|
|
|
|
if (flag_verbose_asm)
|
|
|
|
|
fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
|
|
|
|
|
fputc ('\n', asm_out_file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output double word DATA4. Also output COMMENT if flag_verbose_asm is set.
|
|
|
|
|
Return the data size. Just return the size if DOSIZEONLY is nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_debug_data4 (unsigned long data4, const char *comment, int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
if (!dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
ASM_OUTPUT_DEBUG_DATA4 (asm_out_file, data4);
|
|
|
|
|
if (flag_verbose_asm)
|
|
|
|
|
fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
|
|
|
|
|
fputc ('\n', asm_out_file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 4;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output quad word DATA8. Also output COMMENT if flag_verbose_asm is set.
|
|
|
|
|
Return the data size. Just return the size if DOSIZEONLY is nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_debug_data8 (unsigned long long data8, const char *comment,
|
|
|
|
|
int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
if (!dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
ASM_OUTPUT_DEBUG_DATA8 (asm_out_file, data8);
|
|
|
|
|
if (flag_verbose_asm)
|
|
|
|
|
fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
|
|
|
|
|
fputc ('\n', asm_out_file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 8;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output the difference between LABEL1 and LABEL2. Also output COMMENT if
|
|
|
|
|
flag_verbose_asm is set. Return the data size. Just return the size if
|
|
|
|
|
DOSIZEONLY is nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_debug_delta4 (const char *label1, const char *label2,
|
|
|
|
|
const char *comment, int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
if (!dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
ASM_OUTPUT_DEBUG_DELTA4 (asm_out_file, label1, label2);
|
|
|
|
|
if (flag_verbose_asm)
|
|
|
|
|
fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
|
|
|
|
|
fputc ('\n', asm_out_file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 4;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a character string STRING. Also write COMMENT if flag_verbose_asm is
|
|
|
|
|
set. Return the string length. Just return the length if DOSIZEONLY is
|
|
|
|
|
nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_debug_string (const char *string, const char *comment, int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
if (!dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
ASM_OUTPUT_DEBUG_STRING (asm_out_file, string);
|
|
|
|
|
if (flag_verbose_asm)
|
|
|
|
|
fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
|
|
|
|
|
fputc ('\n', asm_out_file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return strlen (string);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a module begin header and return the header size. Just return the
|
|
|
|
|
size if DOSIZEONLY is nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_modbeg (int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
DST_MODULE_BEGIN modbeg;
|
|
|
|
|
DST_MB_TRLR mb_trlr;
|
|
|
|
|
int i;
|
|
|
|
|
char *module_name, *m;
|
|
|
|
|
int modnamelen;
|
|
|
|
|
int prodnamelen;
|
|
|
|
|
int totsize = 0;
|
|
|
|
|
|
|
|
|
|
/* Assumes primary filename has Unix syntax file spec. */
|
|
|
|
|
module_name = xstrdup (lbasename (primary_filename));
|
|
|
|
|
|
|
|
|
|
m = strrchr (module_name, '.');
|
|
|
|
|
if (m)
|
|
|
|
|
*m = 0;
|
|
|
|
|
|
|
|
|
|
modnamelen = strlen (module_name);
|
|
|
|
|
for (i = 0; i < modnamelen; i++)
|
|
|
|
|
module_name[i] = TOUPPER (module_name[i]);
|
|
|
|
|
|
|
|
|
|
prodnamelen = strlen (module_producer);
|
|
|
|
|
|
|
|
|
|
modbeg.dst_a_modbeg_header.dst__header_length.dst_w_length
|
|
|
|
|
= DST_K_MODBEG_SIZE + modnamelen + DST_K_MB_TRLR_SIZE + prodnamelen - 1;
|
|
|
|
|
modbeg.dst_a_modbeg_header.dst__header_type.dst_w_type = DST_K_MODBEG;
|
|
|
|
|
modbeg.dst_b_modbeg_flags.dst_v_modbeg_hide = 0;
|
|
|
|
|
modbeg.dst_b_modbeg_flags.dst_v_modbeg_version = 1;
|
|
|
|
|
modbeg.dst_b_modbeg_flags.dst_v_modbeg_unused = 0;
|
|
|
|
|
modbeg.dst_b_modbeg_unused = 0;
|
|
|
|
|
modbeg.dst_l_modbeg_language = (DST_LANGUAGE) module_language;
|
|
|
|
|
modbeg.dst_w_version_major = DST_K_VERSION_MAJOR;
|
|
|
|
|
modbeg.dst_w_version_minor = DST_K_VERSION_MINOR;
|
|
|
|
|
modbeg.dst_b_modbeg_name = strlen (module_name);
|
|
|
|
|
|
|
|
|
|
mb_trlr.dst_b_compiler = strlen (module_producer);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header (&modbeg.dst_a_modbeg_header,
|
|
|
|
|
"modbeg", dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (*((char *) &modbeg.dst_b_modbeg_flags),
|
|
|
|
|
"flags", dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (modbeg.dst_b_modbeg_unused,
|
|
|
|
|
"unused", dosizeonly);
|
|
|
|
|
totsize += write_debug_data4 (modbeg.dst_l_modbeg_language,
|
|
|
|
|
"language", dosizeonly);
|
|
|
|
|
totsize += write_debug_data2 (modbeg.dst_w_version_major,
|
|
|
|
|
"DST major version", dosizeonly);
|
|
|
|
|
totsize += write_debug_data2 (modbeg.dst_w_version_minor,
|
|
|
|
|
"DST minor version", dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (modbeg.dst_b_modbeg_name,
|
|
|
|
|
"length of module name", dosizeonly);
|
|
|
|
|
totsize += write_debug_string (module_name, "module name", dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (mb_trlr.dst_b_compiler,
|
|
|
|
|
"length of compiler name", dosizeonly);
|
|
|
|
|
totsize += write_debug_string (module_producer, "compiler name", dosizeonly);
|
|
|
|
|
|
|
|
|
|
return totsize;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a module end trailer and return the trailer size. Just return
|
|
|
|
|
the size if DOSIZEONLY is nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_modend (int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
DST_MODULE_END modend;
|
|
|
|
|
int totsize = 0;
|
|
|
|
|
|
|
|
|
|
modend.dst_a_modend_header.dst__header_length.dst_w_length
|
|
|
|
|
= DST_K_MODEND_SIZE - 1;
|
|
|
|
|
modend.dst_a_modend_header.dst__header_type.dst_w_type = DST_K_MODEND;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header (&modend.dst_a_modend_header, "modend",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
|
|
|
|
|
return totsize;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a routine begin header routine RTNNUM and return the header size.
|
|
|
|
|
Just return the size if DOSIZEONLY is nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_rtnbeg (int rtnnum, int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
const char *rtnname;
|
|
|
|
|
int rtnnamelen;
|
|
|
|
|
char *rtnentryname;
|
|
|
|
|
int totsize = 0;
|
|
|
|
|
char label[MAX_ARTIFICIAL_LABEL_BYTES];
|
|
|
|
|
DST_ROUTINE_BEGIN rtnbeg;
|
|
|
|
|
DST_PROLOG prolog;
|
|
|
|
|
|
2014-09-21 17:33:12 +00:00
|
|
|
|
rtnname = funcnam_table[rtnnum];
|
2012-03-27 23:13:14 +00:00
|
|
|
|
rtnnamelen = strlen (rtnname);
|
|
|
|
|
rtnentryname = concat (rtnname, "..en", NULL);
|
|
|
|
|
|
|
|
|
|
if (!strcmp (rtnname, "main"))
|
|
|
|
|
{
|
|
|
|
|
DST_HEADER header;
|
|
|
|
|
const char *go = "TRANSFER$BREAK$GO";
|
|
|
|
|
|
|
|
|
|
/* This command isn't documented in DSTRECORDS, so it's made to
|
|
|
|
|
look like what DEC C does */
|
|
|
|
|
|
|
|
|
|
/* header size - 1st byte + flag byte + STO_LW size
|
|
|
|
|
+ string count byte + string length */
|
|
|
|
|
header.dst__header_length.dst_w_length
|
|
|
|
|
= DST_K_DST_HEADER_SIZE - 1 + 1 + 4 + 1 + strlen (go);
|
|
|
|
|
header.dst__header_type.dst_w_type = DST_K_TBG;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header (&header, "transfer", dosizeonly);
|
|
|
|
|
|
|
|
|
|
/* I think this is a flag byte, but I don't know what this flag means */
|
|
|
|
|
totsize += write_debug_data1 (0x1, "flags ???", dosizeonly);
|
|
|
|
|
|
|
|
|
|
/* Routine Begin PD Address */
|
|
|
|
|
totsize += write_debug_addr (rtnname, "main procedure descriptor",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (strlen (go), "length of main_name",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
totsize += write_debug_string (go, "main name", dosizeonly);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* The header length never includes the length byte. */
|
|
|
|
|
rtnbeg.dst_a_rtnbeg_header.dst__header_length.dst_w_length
|
|
|
|
|
= DST_K_RTNBEG_SIZE + rtnnamelen - 1;
|
|
|
|
|
rtnbeg.dst_a_rtnbeg_header.dst__header_type.dst_w_type = DST_K_RTNBEG;
|
|
|
|
|
rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_unused = 0;
|
|
|
|
|
rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_unalloc = 0;
|
|
|
|
|
rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_prototype = 0;
|
|
|
|
|
rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_inlined = 0;
|
|
|
|
|
rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_no_call = 1;
|
|
|
|
|
rtnbeg.dst_b_rtnbeg_name = rtnnamelen;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header (&rtnbeg.dst_a_rtnbeg_header, "rtnbeg",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (*((char *) &rtnbeg.dst_b_rtnbeg_flags),
|
|
|
|
|
"flags", dosizeonly);
|
|
|
|
|
|
|
|
|
|
/* Routine Begin Address */
|
|
|
|
|
totsize += write_debug_addr (rtnentryname, "routine entry name", dosizeonly);
|
|
|
|
|
|
|
|
|
|
/* Routine Begin PD Address */
|
|
|
|
|
totsize += write_debug_addr (rtnname, "routine procedure descriptor",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
|
|
|
|
|
/* Routine Begin Name */
|
|
|
|
|
totsize += write_debug_data1 (rtnbeg.dst_b_rtnbeg_name,
|
|
|
|
|
"length of routine name", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_string (rtnname, "routine name", dosizeonly);
|
|
|
|
|
|
|
|
|
|
free (rtnentryname);
|
|
|
|
|
|
|
|
|
|
if (debug_info_level > DINFO_LEVEL_TERSE)
|
|
|
|
|
{
|
|
|
|
|
prolog.dst_a_prolog_header.dst__header_length.dst_w_length
|
|
|
|
|
= DST_K_PROLOG_SIZE - 1;
|
|
|
|
|
prolog.dst_a_prolog_header.dst__header_type.dst_w_type = DST_K_PROLOG;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header (&prolog.dst_a_prolog_header, "prolog",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
|
|
|
|
|
ASM_GENERATE_INTERNAL_LABEL
|
|
|
|
|
(label, FUNC_PROLOG_LABEL,
|
2014-09-21 17:33:12 +00:00
|
|
|
|
funcnum_table[rtnnum]);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
totsize += write_debug_addr (label, "prolog breakpoint addr",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return totsize;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a routine end trailer for routine RTNNUM and return the header size.
|
|
|
|
|
Just return the size if DOSIZEONLY is nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_rtnend (int rtnnum, int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
DST_ROUTINE_END rtnend;
|
|
|
|
|
char label1[MAX_ARTIFICIAL_LABEL_BYTES];
|
|
|
|
|
char label2[MAX_ARTIFICIAL_LABEL_BYTES];
|
|
|
|
|
int totsize;
|
|
|
|
|
|
|
|
|
|
totsize = 0;
|
|
|
|
|
|
|
|
|
|
rtnend.dst_a_rtnend_header.dst__header_length.dst_w_length
|
|
|
|
|
= DST_K_RTNEND_SIZE - 1;
|
|
|
|
|
rtnend.dst_a_rtnend_header.dst__header_type.dst_w_type = DST_K_RTNEND;
|
|
|
|
|
rtnend.dst_b_rtnend_unused = 0;
|
|
|
|
|
rtnend.dst_l_rtnend_size = 0; /* Calculated below. */
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header (&rtnend.dst_a_rtnend_header, "rtnend",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (rtnend.dst_b_rtnend_unused, "unused",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
|
|
|
|
|
ASM_GENERATE_INTERNAL_LABEL
|
|
|
|
|
(label1, FUNC_BEGIN_LABEL,
|
2014-09-21 17:33:12 +00:00
|
|
|
|
funcnum_table[rtnnum]);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
ASM_GENERATE_INTERNAL_LABEL
|
|
|
|
|
(label2, FUNC_END_LABEL,
|
2014-09-21 17:33:12 +00:00
|
|
|
|
funcnum_table[rtnnum]);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
totsize += write_debug_delta4 (label2, label1, "routine size", dosizeonly);
|
|
|
|
|
|
|
|
|
|
return totsize;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define K_DELTA_PC(I) \
|
|
|
|
|
((I) < 128 ? -(I) : (I) < 65536 ? DST_K_DELTA_PC_W : DST_K_DELTA_PC_L)
|
|
|
|
|
|
|
|
|
|
#define K_SET_LINUM(I) \
|
|
|
|
|
((I) < 256 ? DST_K_SET_LINUM_B \
|
|
|
|
|
: (I) < 65536 ? DST_K_SET_LINUM : DST_K_SET_LINUM_L)
|
|
|
|
|
|
|
|
|
|
#define K_INCR_LINUM(I) \
|
|
|
|
|
((I) < 256 ? DST_K_INCR_LINUM \
|
|
|
|
|
: (I) < 65536 ? DST_K_INCR_LINUM_W : DST_K_INCR_LINUM_L)
|
|
|
|
|
|
|
|
|
|
/* Output the PC to line number correlations and return the size. Just return
|
|
|
|
|
the size if DOSIZEONLY is nonzero */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_pclines (int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
unsigned i;
|
|
|
|
|
int fn;
|
|
|
|
|
int ln, lastln;
|
|
|
|
|
int linestart = 0;
|
|
|
|
|
int max_line;
|
|
|
|
|
DST_LINE_NUM_HEADER line_num;
|
|
|
|
|
DST_PCLINE_COMMANDS pcline;
|
|
|
|
|
char label[MAX_ARTIFICIAL_LABEL_BYTES];
|
|
|
|
|
char lastlabel[MAX_ARTIFICIAL_LABEL_BYTES];
|
|
|
|
|
int totsize = 0;
|
|
|
|
|
char buff[256];
|
|
|
|
|
|
|
|
|
|
max_line = file_info_table[1].max_line;
|
|
|
|
|
file_info_table[1].listing_line_start = linestart;
|
|
|
|
|
linestart = linestart + ((max_line / 100000) + 1) * 100000;
|
|
|
|
|
|
|
|
|
|
for (i = 2; i < file_info_table_in_use; i++)
|
|
|
|
|
{
|
|
|
|
|
max_line = file_info_table[i].max_line;
|
|
|
|
|
file_info_table[i].listing_line_start = linestart;
|
|
|
|
|
linestart = linestart + ((max_line / 10000) + 1) * 10000;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set starting address to beginning of text section. */
|
|
|
|
|
line_num.dst_a_line_num_header.dst__header_length.dst_w_length = 8;
|
|
|
|
|
line_num.dst_a_line_num_header.dst__header_type.dst_w_type = DST_K_LINE_NUM;
|
|
|
|
|
pcline.dst_b_pcline_command = DST_K_SET_ABS_PC;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header (&line_num.dst_a_line_num_header,
|
|
|
|
|
"line_num", dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (pcline.dst_b_pcline_command,
|
|
|
|
|
"line_num (SET ABS PC)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
if (dosizeonly)
|
|
|
|
|
totsize += 4;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
ASM_OUTPUT_DEBUG_ADDR (asm_out_file, TEXT_SECTION_ASM_OP);
|
|
|
|
|
if (flag_verbose_asm)
|
|
|
|
|
fprintf (asm_out_file, "\t%s line_num", ASM_COMMENT_START);
|
|
|
|
|
fputc ('\n', asm_out_file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn = line_info_table[1].dst_file_num;
|
|
|
|
|
ln = (file_info_table[fn].listing_line_start
|
|
|
|
|
+ line_info_table[1].dst_line_num);
|
|
|
|
|
line_num.dst_a_line_num_header.dst__header_length.dst_w_length = 4 + 4;
|
|
|
|
|
pcline.dst_b_pcline_command = DST_K_SET_LINUM_L;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header (&line_num.dst_a_line_num_header,
|
|
|
|
|
"line_num", dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (pcline.dst_b_pcline_command,
|
|
|
|
|
"line_num (SET LINUM LONG)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
sprintf (buff, "line_num (%d)", ln ? ln - 1 : 0);
|
|
|
|
|
totsize += write_debug_data4 (ln ? ln - 1 : 0, buff, dosizeonly);
|
|
|
|
|
|
|
|
|
|
lastln = ln;
|
|
|
|
|
strcpy (lastlabel, TEXT_SECTION_ASM_OP);
|
|
|
|
|
for (i = 1; i < line_info_table_in_use; i++)
|
|
|
|
|
{
|
|
|
|
|
int extrabytes;
|
|
|
|
|
|
|
|
|
|
fn = line_info_table[i].dst_file_num;
|
|
|
|
|
ln = (file_info_table[fn].listing_line_start
|
|
|
|
|
+ line_info_table[i].dst_line_num);
|
|
|
|
|
|
|
|
|
|
if (ln - lastln > 1)
|
|
|
|
|
extrabytes = 5; /* NUMBYTES (ln - lastln - 1) + 1; */
|
|
|
|
|
else if (ln <= lastln)
|
|
|
|
|
extrabytes = 5; /* NUMBYTES (ln - 1) + 1; */
|
|
|
|
|
else
|
|
|
|
|
extrabytes = 0;
|
|
|
|
|
|
|
|
|
|
line_num.dst_a_line_num_header.dst__header_length.dst_w_length
|
|
|
|
|
= 8 + extrabytes;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header
|
|
|
|
|
(&line_num.dst_a_line_num_header, "line_num", dosizeonly);
|
|
|
|
|
|
|
|
|
|
if (ln - lastln > 1)
|
|
|
|
|
{
|
|
|
|
|
int lndif = ln - lastln - 1;
|
|
|
|
|
|
|
|
|
|
/* K_INCR_LINUM (lndif); */
|
|
|
|
|
pcline.dst_b_pcline_command = DST_K_INCR_LINUM_L;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data1 (pcline.dst_b_pcline_command,
|
|
|
|
|
"line_num (INCR LINUM LONG)",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
|
|
|
|
|
sprintf (buff, "line_num (%d)", lndif);
|
|
|
|
|
totsize += write_debug_data4 (lndif, buff, dosizeonly);
|
|
|
|
|
}
|
|
|
|
|
else if (ln <= lastln)
|
|
|
|
|
{
|
|
|
|
|
/* K_SET_LINUM (ln-1); */
|
|
|
|
|
pcline.dst_b_pcline_command = DST_K_SET_LINUM_L;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data1 (pcline.dst_b_pcline_command,
|
|
|
|
|
"line_num (SET LINUM LONG)",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
|
|
|
|
|
sprintf (buff, "line_num (%d)", ln - 1);
|
|
|
|
|
totsize += write_debug_data4 (ln - 1, buff, dosizeonly);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pcline.dst_b_pcline_command = DST_K_DELTA_PC_L;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data1 (pcline.dst_b_pcline_command,
|
|
|
|
|
"line_num (DELTA PC LONG)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
ASM_GENERATE_INTERNAL_LABEL (label, LINE_CODE_LABEL, i);
|
|
|
|
|
totsize += write_debug_delta4 (label, lastlabel, "increment line_num",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
|
|
|
|
|
lastln = ln;
|
|
|
|
|
strcpy (lastlabel, label);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return totsize;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a source correlation for file FILEID using information saved in
|
|
|
|
|
FILE_INFO_ENTRY and return the size. Just return the size if DOSIZEONLY is
|
|
|
|
|
nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_srccorr (int fileid, dst_file_info_entry file_info_entry,
|
|
|
|
|
int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
int src_command_size;
|
|
|
|
|
int linesleft = file_info_entry.max_line;
|
|
|
|
|
int linestart = file_info_entry.listing_line_start;
|
|
|
|
|
int flen = strlen (file_info_entry.file_name);
|
|
|
|
|
int linestodo = 0;
|
|
|
|
|
DST_SOURCE_CORR src_header;
|
|
|
|
|
DST_SRC_COMMAND src_command;
|
|
|
|
|
DST_SRC_COMMAND src_command_sf;
|
|
|
|
|
DST_SRC_COMMAND src_command_sl;
|
|
|
|
|
DST_SRC_COMMAND src_command_sr;
|
|
|
|
|
DST_SRC_COMMAND src_command_dl;
|
|
|
|
|
DST_SRC_CMDTRLR src_cmdtrlr;
|
|
|
|
|
char buff[256];
|
|
|
|
|
int totsize = 0;
|
|
|
|
|
|
|
|
|
|
if (fileid == 1)
|
|
|
|
|
{
|
|
|
|
|
src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
|
|
|
|
|
= DST_K_SOURCE_CORR_HEADER_SIZE + 1 - 1;
|
|
|
|
|
src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
|
|
|
|
|
= DST_K_SOURCE;
|
|
|
|
|
src_command.dst_b_src_command = DST_K_SRC_FORMFEED;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header (&src_header.dst_a_source_corr_header,
|
|
|
|
|
"source corr", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data1 (src_command.dst_b_src_command,
|
|
|
|
|
"source_corr (SRC FORMFEED)",
|
|
|
|
|
dosizeonly);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
src_command_size
|
|
|
|
|
= DST_K_SRC_COMMAND_SIZE + flen + DST_K_SRC_CMDTRLR_SIZE;
|
|
|
|
|
src_command.dst_b_src_command = DST_K_SRC_DECLFILE;
|
|
|
|
|
src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_length
|
|
|
|
|
= src_command_size - 2;
|
|
|
|
|
src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_flags = 0;
|
|
|
|
|
src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_fileid
|
|
|
|
|
= fileid;
|
|
|
|
|
src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_q_src_df_rms_cdt
|
|
|
|
|
= file_info_entry.cdt;
|
|
|
|
|
src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_l_src_df_rms_ebk
|
|
|
|
|
= file_info_entry.ebk;
|
|
|
|
|
src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_rms_ffb
|
|
|
|
|
= file_info_entry.ffb;
|
|
|
|
|
src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_rms_rfo
|
|
|
|
|
= file_info_entry.rfo;
|
|
|
|
|
src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_filename
|
|
|
|
|
= flen;
|
|
|
|
|
|
|
|
|
|
src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
|
|
|
|
|
= DST_K_SOURCE_CORR_HEADER_SIZE + src_command_size - 1;
|
|
|
|
|
src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
|
|
|
|
|
= DST_K_SOURCE;
|
|
|
|
|
|
|
|
|
|
src_cmdtrlr.dst_b_src_df_libmodname = 0;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header (&src_header.dst_a_source_corr_header,
|
|
|
|
|
"source corr", dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (src_command.dst_b_src_command,
|
|
|
|
|
"source_corr (DECL SRC FILE)", dosizeonly);
|
|
|
|
|
totsize += write_debug_data1
|
|
|
|
|
(src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_length,
|
|
|
|
|
"source_corr (length)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data1
|
|
|
|
|
(src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_flags,
|
|
|
|
|
"source_corr (flags)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data2
|
|
|
|
|
(src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_fileid,
|
|
|
|
|
"source_corr (fileid)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data8
|
|
|
|
|
(src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_q_src_df_rms_cdt,
|
|
|
|
|
"source_corr (creation date)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data4
|
|
|
|
|
(src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_l_src_df_rms_ebk,
|
|
|
|
|
"source_corr (EOF block number)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data2
|
|
|
|
|
(src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_rms_ffb,
|
|
|
|
|
"source_corr (first free byte)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data1
|
|
|
|
|
(src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_rms_rfo,
|
|
|
|
|
"source_corr (record and file organization)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data1
|
|
|
|
|
(src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_filename,
|
|
|
|
|
"source_corr (filename length)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_string (remap_debug_filename (
|
|
|
|
|
file_info_entry.file_name),
|
|
|
|
|
"source file name", dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (src_cmdtrlr.dst_b_src_df_libmodname,
|
|
|
|
|
"source_corr (libmodname)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
src_command_sf.dst_b_src_command = DST_K_SRC_SETFILE;
|
|
|
|
|
src_command_sf.dst_a_src_cmd_fields.dst_w_src_unsword = fileid;
|
|
|
|
|
|
|
|
|
|
src_command_sr.dst_b_src_command = DST_K_SRC_SETREC_W;
|
|
|
|
|
src_command_sr.dst_a_src_cmd_fields.dst_w_src_unsword = 1;
|
|
|
|
|
|
|
|
|
|
src_command_sl.dst_b_src_command = DST_K_SRC_SETLNUM_L;
|
|
|
|
|
src_command_sl.dst_a_src_cmd_fields.dst_l_src_unslong = linestart + 1;
|
|
|
|
|
|
|
|
|
|
src_command_dl.dst_b_src_command = DST_K_SRC_DEFLINES_W;
|
|
|
|
|
|
|
|
|
|
if (linesleft > 65534)
|
|
|
|
|
linesleft = linesleft - 65534, linestodo = 65534;
|
|
|
|
|
else
|
|
|
|
|
linestodo = linesleft, linesleft = 0;
|
|
|
|
|
|
|
|
|
|
src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword = linestodo;
|
|
|
|
|
|
|
|
|
|
src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
|
|
|
|
|
= DST_K_SOURCE_CORR_HEADER_SIZE + 3 + 3 + 5 + 3 - 1;
|
|
|
|
|
src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
|
|
|
|
|
= DST_K_SOURCE;
|
|
|
|
|
|
|
|
|
|
if (src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword)
|
|
|
|
|
{
|
|
|
|
|
totsize += write_debug_header (&src_header.dst_a_source_corr_header,
|
|
|
|
|
"source corr", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data1 (src_command_sf.dst_b_src_command,
|
|
|
|
|
"source_corr (src setfile)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data2
|
|
|
|
|
(src_command_sf.dst_a_src_cmd_fields.dst_w_src_unsword,
|
|
|
|
|
"source_corr (fileid)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data1 (src_command_sr.dst_b_src_command,
|
|
|
|
|
"source_corr (setrec)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data2
|
|
|
|
|
(src_command_sr.dst_a_src_cmd_fields.dst_w_src_unsword,
|
|
|
|
|
"source_corr (recnum)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data1 (src_command_sl.dst_b_src_command,
|
|
|
|
|
"source_corr (setlnum)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data4
|
|
|
|
|
(src_command_sl.dst_a_src_cmd_fields.dst_l_src_unslong,
|
|
|
|
|
"source_corr (linenum)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_data1 (src_command_dl.dst_b_src_command,
|
|
|
|
|
"source_corr (deflines)", dosizeonly);
|
|
|
|
|
|
|
|
|
|
sprintf (buff, "source_corr (%d)",
|
|
|
|
|
src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword);
|
|
|
|
|
totsize += write_debug_data2
|
|
|
|
|
(src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword,
|
|
|
|
|
buff, dosizeonly);
|
|
|
|
|
|
|
|
|
|
while (linesleft > 0)
|
|
|
|
|
{
|
|
|
|
|
src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
|
|
|
|
|
= DST_K_SOURCE_CORR_HEADER_SIZE + 3 - 1;
|
|
|
|
|
src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
|
|
|
|
|
= DST_K_SOURCE;
|
|
|
|
|
src_command_dl.dst_b_src_command = DST_K_SRC_DEFLINES_W;
|
|
|
|
|
|
|
|
|
|
if (linesleft > 65534)
|
|
|
|
|
linesleft = linesleft - 65534, linestodo = 65534;
|
|
|
|
|
else
|
|
|
|
|
linestodo = linesleft, linesleft = 0;
|
|
|
|
|
|
|
|
|
|
src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword = linestodo;
|
|
|
|
|
|
|
|
|
|
totsize += write_debug_header (&src_header.dst_a_source_corr_header,
|
|
|
|
|
"source corr", dosizeonly);
|
|
|
|
|
totsize += write_debug_data1 (src_command_dl.dst_b_src_command,
|
|
|
|
|
"source_corr (deflines)", dosizeonly);
|
|
|
|
|
sprintf (buff, "source_corr (%d)",
|
|
|
|
|
src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword);
|
|
|
|
|
totsize += write_debug_data2
|
|
|
|
|
(src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword,
|
|
|
|
|
buff, dosizeonly);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return totsize;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output all the source correlation entries and return the size. Just return
|
|
|
|
|
the size if DOSIZEONLY is nonzero. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
write_srccorrs (int dosizeonly)
|
|
|
|
|
{
|
|
|
|
|
unsigned int i;
|
|
|
|
|
int totsize = 0;
|
|
|
|
|
|
|
|
|
|
for (i = 1; i < file_info_table_in_use; i++)
|
|
|
|
|
totsize += write_srccorr (i, file_info_table[i], dosizeonly);
|
|
|
|
|
|
|
|
|
|
return totsize;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a marker (i.e. a label) for the beginning of a function, before
|
|
|
|
|
the prologue. */
|
|
|
|
|
|
|
|
|
|
static void
|
2017-10-07 00:16:47 +00:00
|
|
|
|
vmsdbgout_begin_prologue (unsigned int line, unsigned int column,
|
|
|
|
|
const char *file)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
char label[MAX_ARTIFICIAL_LABEL_BYTES];
|
|
|
|
|
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
2017-10-07 00:16:47 +00:00
|
|
|
|
(*dwarf2_debug_hooks.begin_prologue) (line, column, file);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
if (debug_info_level > DINFO_LEVEL_NONE)
|
|
|
|
|
{
|
|
|
|
|
ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
|
|
|
|
|
current_function_funcdef_no);
|
|
|
|
|
ASM_OUTPUT_LABEL (asm_out_file, label);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a marker (i.e. a label) for the beginning of a function, after
|
|
|
|
|
the prologue. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_end_prologue (unsigned int line, const char *file)
|
|
|
|
|
{
|
|
|
|
|
char label[MAX_ARTIFICIAL_LABEL_BYTES];
|
|
|
|
|
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.end_prologue) (line, file);
|
|
|
|
|
|
|
|
|
|
if (debug_info_level > DINFO_LEVEL_TERSE)
|
|
|
|
|
{
|
|
|
|
|
ASM_GENERATE_INTERNAL_LABEL (label, FUNC_PROLOG_LABEL,
|
|
|
|
|
current_function_funcdef_no);
|
|
|
|
|
ASM_OUTPUT_LABEL (asm_out_file, label);
|
|
|
|
|
|
|
|
|
|
/* VMS PCA expects every PC range to correlate to some line and file. */
|
|
|
|
|
vmsdbgout_write_source_line (line, file, 0, true);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* No output for VMS debug, but make obligatory call to Dwarf2 debug */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_end_function (unsigned int line)
|
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.end_function) (line);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a marker (i.e. a label) for the beginning of the epilogue.
|
|
|
|
|
This gets called *before* the epilogue code has been generated. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_begin_epilogue (unsigned int line, const char *file)
|
|
|
|
|
{
|
|
|
|
|
char label[MAX_ARTIFICIAL_LABEL_BYTES];
|
|
|
|
|
static int save_current_function_funcdef_no = -1;
|
|
|
|
|
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.begin_epilogue) (line, file);
|
|
|
|
|
|
|
|
|
|
if (debug_info_level > DINFO_LEVEL_NONE)
|
|
|
|
|
{
|
|
|
|
|
if (save_current_function_funcdef_no != current_function_funcdef_no)
|
|
|
|
|
{
|
|
|
|
|
/* Output a label to mark the endpoint of the code generated for this
|
|
|
|
|
function. */
|
|
|
|
|
ASM_GENERATE_INTERNAL_LABEL (label, FUNC_EPILOG_LABEL,
|
|
|
|
|
current_function_funcdef_no);
|
|
|
|
|
|
|
|
|
|
ASM_OUTPUT_LABEL (asm_out_file, label);
|
|
|
|
|
|
|
|
|
|
save_current_function_funcdef_no = current_function_funcdef_no;
|
|
|
|
|
|
|
|
|
|
/* VMS PCA expects every PC range to correlate to some line and
|
|
|
|
|
file. */
|
|
|
|
|
vmsdbgout_write_source_line (line, file, 0, true);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a marker (i.e. a label) for the absolute end of the generated code
|
|
|
|
|
for a function definition. This gets called *after* the epilogue code has
|
|
|
|
|
been generated. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_end_epilogue (unsigned int line, const char *file)
|
|
|
|
|
{
|
|
|
|
|
char label[MAX_ARTIFICIAL_LABEL_BYTES];
|
|
|
|
|
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.end_epilogue) (line, file);
|
|
|
|
|
|
|
|
|
|
if (debug_info_level > DINFO_LEVEL_NONE)
|
|
|
|
|
{
|
|
|
|
|
/* Output a label to mark the endpoint of the code generated for this
|
|
|
|
|
function. */
|
|
|
|
|
ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
|
|
|
|
|
current_function_funcdef_no);
|
|
|
|
|
ASM_OUTPUT_LABEL (asm_out_file, label);
|
|
|
|
|
|
|
|
|
|
/* VMS PCA expects every PC range to correlate to some line and file. */
|
|
|
|
|
vmsdbgout_write_source_line (line, file, 0, true);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a marker (i.e. a label) for the beginning of the generated code for
|
|
|
|
|
a lexical block. */
|
|
|
|
|
|
|
|
|
|
static void
|
2022-10-27 18:55:19 +00:00
|
|
|
|
vmsdbgout_begin_block (unsigned line, unsigned blocknum)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.begin_block) (line, blocknum);
|
|
|
|
|
|
|
|
|
|
if (debug_info_level > DINFO_LEVEL_TERSE)
|
|
|
|
|
targetm.asm_out.internal_label (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a marker (i.e. a label) for the end of the generated code for a
|
|
|
|
|
lexical block. */
|
|
|
|
|
|
|
|
|
|
static void
|
2022-10-27 18:55:19 +00:00
|
|
|
|
vmsdbgout_end_block (unsigned line, unsigned blocknum)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.end_block) (line, blocknum);
|
|
|
|
|
|
|
|
|
|
if (debug_info_level > DINFO_LEVEL_TERSE)
|
|
|
|
|
targetm.asm_out.internal_label (asm_out_file, BLOCK_END_LABEL, blocknum);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Not implemented in VMS Debug. */
|
|
|
|
|
|
|
|
|
|
static bool
|
|
|
|
|
vmsdbgout_ignore_block (const_tree block)
|
|
|
|
|
{
|
|
|
|
|
bool retval = 0;
|
|
|
|
|
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
retval = (*dwarf2_debug_hooks.ignore_block) (block);
|
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add an entry for function DECL into the funcnam_table. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_begin_function (tree decl)
|
|
|
|
|
{
|
|
|
|
|
const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
|
|
|
|
|
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.begin_function) (decl);
|
|
|
|
|
|
|
|
|
|
/* Add the new entry to the end of the function name table. */
|
2014-09-21 17:33:12 +00:00
|
|
|
|
funcnam_table.safe_push (xstrdup (name));
|
|
|
|
|
funcnum_table.safe_push (current_function_funcdef_no);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static char fullname_buff [4096];
|
|
|
|
|
|
|
|
|
|
/* Return the full file specification for FILENAME. The specification must be
|
|
|
|
|
in VMS syntax in order to be processed by VMS Debug. */
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
|
full_name (const char *filename)
|
|
|
|
|
{
|
|
|
|
|
#ifdef VMS
|
|
|
|
|
FILE *fp = fopen (filename, "r");
|
|
|
|
|
|
|
|
|
|
fgetname (fp, fullname_buff, 1);
|
|
|
|
|
fclose (fp);
|
|
|
|
|
#else
|
|
|
|
|
/* Unix paths really mess up VMS debug. Better to just output the
|
|
|
|
|
base filename. */
|
|
|
|
|
strcpy (fullname_buff, filename);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return fullname_buff;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Lookup a filename (in the list of filenames that we know about here in
|
2022-10-27 18:55:19 +00:00
|
|
|
|
vmsdbgout.cc) and return its "index". The index of each (known) filename is
|
2012-03-27 23:13:14 +00:00
|
|
|
|
just a unique number which is associated with only that one filename. We
|
|
|
|
|
need such numbers for the sake of generating labels and references
|
|
|
|
|
to those files numbers. If the filename given as an argument is not
|
|
|
|
|
found in our current list, add it to the list and assign it the next
|
|
|
|
|
available unique index number. In order to speed up searches, we remember
|
|
|
|
|
the index of the filename was looked up last. This handles the majority of
|
|
|
|
|
all searches. */
|
|
|
|
|
|
|
|
|
|
static unsigned int
|
|
|
|
|
lookup_filename (const char *file_name)
|
|
|
|
|
{
|
|
|
|
|
static unsigned int last_file_lookup_index = 0;
|
2022-10-27 18:55:19 +00:00
|
|
|
|
char *fn;
|
|
|
|
|
unsigned i;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
const char *fnam;
|
|
|
|
|
long long cdt = 0;
|
|
|
|
|
long ebk = 0;
|
|
|
|
|
short ffb = 0;
|
|
|
|
|
char rfo = 0;
|
|
|
|
|
long siz = 0;
|
|
|
|
|
int ver = 0;
|
|
|
|
|
|
|
|
|
|
fnam = full_name (file_name);
|
|
|
|
|
|
|
|
|
|
/* Check to see if the file name that was searched on the previous call
|
|
|
|
|
matches this file name. If so, return the index. */
|
|
|
|
|
if (last_file_lookup_index != 0)
|
|
|
|
|
{
|
|
|
|
|
fn = file_info_table[last_file_lookup_index].file_name;
|
|
|
|
|
if (strcmp (fnam, fn) == 0)
|
|
|
|
|
return last_file_lookup_index;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Didn't match the previous lookup, search the table */
|
|
|
|
|
for (i = 1; i < file_info_table_in_use; ++i)
|
|
|
|
|
{
|
|
|
|
|
fn = file_info_table[i].file_name;
|
|
|
|
|
if (strcmp (fnam, fn) == 0)
|
|
|
|
|
{
|
|
|
|
|
last_file_lookup_index = i;
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Prepare to add a new table entry by making sure there is enough space in
|
|
|
|
|
the table to do so. If not, expand the current table. */
|
|
|
|
|
if (file_info_table_in_use == file_info_table_allocated)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
file_info_table_allocated += FILE_TABLE_INCREMENT;
|
|
|
|
|
file_info_table = XRESIZEVEC (dst_file_info_entry, file_info_table,
|
|
|
|
|
file_info_table_allocated);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (vms_file_stats_name (file_name, &cdt, &siz, &rfo, &ver) == 0)
|
|
|
|
|
{
|
|
|
|
|
ebk = siz / 512 + 1;
|
|
|
|
|
ffb = siz - ((siz / 512) * 512);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add the new entry to the end of the filename table. */
|
|
|
|
|
file_info_table[file_info_table_in_use].file_name = xstrdup (fnam);
|
|
|
|
|
file_info_table[file_info_table_in_use].max_line = 0;
|
|
|
|
|
file_info_table[file_info_table_in_use].cdt = cdt;
|
|
|
|
|
file_info_table[file_info_table_in_use].ebk = ebk;
|
|
|
|
|
file_info_table[file_info_table_in_use].ffb = ffb;
|
|
|
|
|
file_info_table[file_info_table_in_use].rfo = rfo;
|
|
|
|
|
|
|
|
|
|
last_file_lookup_index = file_info_table_in_use++;
|
|
|
|
|
return last_file_lookup_index;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Output a label to mark the beginning of a source code line entry
|
|
|
|
|
and record information relating to this source line, in
|
|
|
|
|
'line_info_table' for later output of the .debug_line section. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_write_source_line (unsigned line, const char *filename,
|
2014-09-21 17:33:12 +00:00
|
|
|
|
int /* discriminator */, bool /* is_stmt */)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
dst_line_info_ref line_info;
|
|
|
|
|
|
|
|
|
|
targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
|
|
|
|
|
line_info_table_in_use);
|
|
|
|
|
|
|
|
|
|
/* Expand the line info table if necessary. */
|
|
|
|
|
if (line_info_table_in_use == line_info_table_allocated)
|
|
|
|
|
{
|
|
|
|
|
line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
|
|
|
|
|
line_info_table = XRESIZEVEC (dst_line_info_entry, line_info_table,
|
|
|
|
|
line_info_table_allocated);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add the new entry at the end of the line_info_table. */
|
|
|
|
|
line_info = &line_info_table[line_info_table_in_use++];
|
|
|
|
|
line_info->dst_file_num = lookup_filename (filename);
|
|
|
|
|
line_info->dst_line_num = line;
|
|
|
|
|
if (line > file_info_table[line_info->dst_file_num].max_line)
|
|
|
|
|
file_info_table[line_info->dst_file_num].max_line = line;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2022-10-27 18:55:19 +00:00
|
|
|
|
vmsdbgout_source_line (unsigned line, unsigned int column,
|
|
|
|
|
const char *filename,
|
2012-03-27 23:13:14 +00:00
|
|
|
|
int discriminator, bool is_stmt)
|
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
2017-10-07 00:16:47 +00:00
|
|
|
|
(*dwarf2_debug_hooks.source_line) (line, column, filename, discriminator,
|
|
|
|
|
is_stmt);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
if (debug_info_level >= DINFO_LEVEL_TERSE)
|
|
|
|
|
vmsdbgout_write_source_line (line, filename, discriminator, is_stmt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Record the beginning of a new source file, for later output.
|
|
|
|
|
At present, unimplemented. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_start_source_file (unsigned int lineno, const char *filename)
|
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.start_source_file) (lineno, filename);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Record the end of a source file, for later output.
|
|
|
|
|
At present, unimplemented. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
|
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.end_source_file) (lineno);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set up for Debug output at the start of compilation. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_init (const char *filename)
|
|
|
|
|
{
|
|
|
|
|
const char *language_string = lang_hooks.name;
|
|
|
|
|
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.init) (filename);
|
|
|
|
|
|
|
|
|
|
if (debug_info_level == DINFO_LEVEL_NONE)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Remember the name of the primary input file. */
|
|
|
|
|
primary_filename = filename;
|
|
|
|
|
|
|
|
|
|
/* Allocate the initial hunk of the file_info_table. */
|
|
|
|
|
file_info_table = XCNEWVEC (dst_file_info_entry, FILE_TABLE_INCREMENT);
|
|
|
|
|
file_info_table_allocated = FILE_TABLE_INCREMENT;
|
|
|
|
|
/* Skip the first entry - file numbers begin at 1. */
|
|
|
|
|
file_info_table_in_use = 1;
|
|
|
|
|
|
2014-09-21 17:33:12 +00:00
|
|
|
|
funcnam_table.create (FUNC_TABLE_INITIAL);
|
|
|
|
|
funcnum_table.create (FUNC_TABLE_INITIAL);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
/* Allocate the initial hunk of the line_info_table. */
|
|
|
|
|
line_info_table = XCNEWVEC (dst_line_info_entry, LINE_INFO_TABLE_INCREMENT);
|
|
|
|
|
line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
|
|
|
|
|
/* zero-th entry is allocated, but unused */
|
|
|
|
|
line_info_table_in_use = 1;
|
|
|
|
|
|
|
|
|
|
lookup_filename (primary_filename);
|
|
|
|
|
|
2015-08-28 15:33:40 +00:00
|
|
|
|
if (lang_GNU_C ())
|
2012-03-27 23:13:14 +00:00
|
|
|
|
module_language = DST_K_C;
|
2015-08-28 15:33:40 +00:00
|
|
|
|
else if (lang_GNU_CXX ())
|
2012-03-27 23:13:14 +00:00
|
|
|
|
module_language = DST_K_CXX;
|
|
|
|
|
else if (!strcmp (language_string, "GNU Ada"))
|
|
|
|
|
module_language = DST_K_ADA;
|
|
|
|
|
else if (!strcmp (language_string, "GNU F77"))
|
|
|
|
|
module_language = DST_K_FORTRAN;
|
|
|
|
|
else
|
|
|
|
|
module_language = DST_K_UNKNOWN;
|
|
|
|
|
|
|
|
|
|
module_producer = concat (language_string, " ", version_string, NULL);
|
|
|
|
|
|
|
|
|
|
ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Not implemented in VMS Debug. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_assembly_start (void)
|
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.assembly_start) ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Not implemented in VMS Debug. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_define (unsigned int lineno, const char *buffer)
|
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.define) (lineno, buffer);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Not implemented in VMS Debug. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_undef (unsigned int lineno, const char *buffer)
|
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.undef) (lineno, buffer);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Not implemented in VMS Debug. */
|
|
|
|
|
|
|
|
|
|
static void
|
2017-04-10 11:32:00 +00:00
|
|
|
|
vmsdbgout_function_decl (tree decl)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.function_decl) (decl);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Not implemented in VMS Debug. */
|
|
|
|
|
|
|
|
|
|
static void
|
2017-04-10 11:32:00 +00:00
|
|
|
|
vmsdbgout_early_global_decl (tree decl)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
2017-04-10 11:32:00 +00:00
|
|
|
|
(*dwarf2_debug_hooks.early_global_decl) (decl);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Not implemented in VMS Debug. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_late_global_decl (tree decl)
|
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.late_global_decl) (decl);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Not implemented in VMS Debug. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_type_decl (tree decl, int local)
|
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.type_decl) (decl, local);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Not implemented in VMS Debug. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_abstract_function (tree decl)
|
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.outlining_inline_function) (decl);
|
|
|
|
|
}
|
|
|
|
|
|
2018-12-28 15:30:48 +00:00
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_early_finish (const char *filename)
|
|
|
|
|
{
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.early_finish) (filename);
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-27 23:13:14 +00:00
|
|
|
|
/* Output stuff that Debug requires at the end of every file and generate the
|
|
|
|
|
VMS Debug debugging info. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vmsdbgout_finish (const char *filename ATTRIBUTE_UNUSED)
|
|
|
|
|
{
|
|
|
|
|
unsigned int i, ifunc;
|
|
|
|
|
int totsize;
|
|
|
|
|
|
|
|
|
|
if (write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
|
|
(*dwarf2_debug_hooks.finish) (filename);
|
|
|
|
|
|
|
|
|
|
if (debug_info_level == DINFO_LEVEL_NONE)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Output a terminator label for the .text section. */
|
|
|
|
|
switch_to_section (text_section);
|
|
|
|
|
targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
|
|
|
|
|
|
|
|
|
|
/* Output debugging information.
|
|
|
|
|
Warning! Do not change the name of the .vmsdebug section without
|
|
|
|
|
changing it in the assembler also. */
|
|
|
|
|
switch_to_section (get_named_section (NULL, ".vmsdebug", 0));
|
|
|
|
|
ASM_OUTPUT_ALIGN (asm_out_file, 0);
|
|
|
|
|
|
|
|
|
|
totsize = write_modbeg (1);
|
2014-09-21 17:33:12 +00:00
|
|
|
|
FOR_EACH_VEC_ELT (funcnum_table, i, ifunc)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
totsize += write_rtnbeg (i, 1);
|
|
|
|
|
totsize += write_rtnend (i, 1);
|
|
|
|
|
}
|
|
|
|
|
totsize += write_pclines (1);
|
|
|
|
|
|
|
|
|
|
write_modbeg (0);
|
2014-09-21 17:33:12 +00:00
|
|
|
|
FOR_EACH_VEC_ELT (funcnum_table, i, ifunc)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
write_rtnbeg (i, 0);
|
|
|
|
|
write_rtnend (i, 0);
|
|
|
|
|
}
|
|
|
|
|
write_pclines (0);
|
|
|
|
|
|
|
|
|
|
if (debug_info_level > DINFO_LEVEL_TERSE)
|
|
|
|
|
{
|
|
|
|
|
totsize = write_srccorrs (1);
|
|
|
|
|
write_srccorrs (0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
totsize = write_modend (1);
|
|
|
|
|
write_modend (0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Need for both Dwarf2 on IVMS and VMS Debug on AVMS */
|
|
|
|
|
|
|
|
|
|
#ifdef VMS
|
|
|
|
|
#define __NEW_STARLET 1
|
|
|
|
|
#include <vms/rms.h>
|
|
|
|
|
#include <vms/atrdef.h>
|
|
|
|
|
#include <vms/fibdef.h>
|
|
|
|
|
#include <vms/stsdef.h>
|
|
|
|
|
#include <vms/iodef.h>
|
|
|
|
|
#include <vms/fatdef.h>
|
|
|
|
|
#include <vms/descrip.h>
|
|
|
|
|
#include <unixlib.h>
|
|
|
|
|
|
|
|
|
|
#define MAXPATH 256
|
|
|
|
|
|
|
|
|
|
/* descrip.h doesn't have everything ... */
|
|
|
|
|
typedef struct fibdef* __fibdef_ptr32 __attribute__ (( mode (SI) ));
|
|
|
|
|
struct dsc$descriptor_fib
|
|
|
|
|
{
|
|
|
|
|
unsigned int fib$l_len;
|
|
|
|
|
__fibdef_ptr32 fib$l_addr;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* I/O Status Block. */
|
|
|
|
|
struct IOSB
|
|
|
|
|
{
|
|
|
|
|
unsigned short status, count;
|
|
|
|
|
unsigned int devdep;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static char *tryfile;
|
|
|
|
|
|
|
|
|
|
/* Variable length string. */
|
|
|
|
|
struct vstring
|
|
|
|
|
{
|
|
|
|
|
short length;
|
|
|
|
|
char string[NAM$C_MAXRSS+1];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static char filename_buff [MAXPATH];
|
|
|
|
|
static char vms_filespec [MAXPATH];
|
|
|
|
|
|
|
|
|
|
/* Callback function for filespec style conversion. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
translate_unix (char *name, int type ATTRIBUTE_UNUSED)
|
|
|
|
|
{
|
|
|
|
|
strncpy (filename_buff, name, MAXPATH);
|
|
|
|
|
filename_buff [MAXPATH - 1] = (char) 0;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Wrapper for DECC function that converts a Unix filespec
|
|
|
|
|
to VMS style filespec. */
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
|
to_vms_file_spec (char *filespec)
|
|
|
|
|
{
|
|
|
|
|
strncpy (vms_filespec, "", MAXPATH);
|
|
|
|
|
decc$to_vms (filespec, translate_unix, 1, 1);
|
|
|
|
|
strncpy (vms_filespec, filename_buff, MAXPATH);
|
|
|
|
|
|
|
|
|
|
vms_filespec [MAXPATH - 1] = (char) 0;
|
|
|
|
|
|
|
|
|
|
return vms_filespec;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else
|
2014-09-21 17:33:12 +00:00
|
|
|
|
#define VMS_EPOCH_OFFSET 35067168000000000LL
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#define VMS_GRANULARITY_FACTOR 10000000
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Return VMS file date, size, format, version given a name. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
vms_file_stats_name (const char *filename, long long *cdt, long *siz, char *rfo,
|
|
|
|
|
int *ver)
|
|
|
|
|
{
|
|
|
|
|
#ifdef VMS
|
|
|
|
|
struct FAB fab;
|
|
|
|
|
struct NAM nam;
|
|
|
|
|
|
|
|
|
|
unsigned long long create;
|
|
|
|
|
FAT recattr;
|
|
|
|
|
char ascnamebuff [256];
|
|
|
|
|
|
|
|
|
|
ATRDEF atrlst[]
|
|
|
|
|
= {
|
|
|
|
|
{ ATR$S_CREDATE, ATR$C_CREDATE, &create },
|
|
|
|
|
{ ATR$S_RECATTR, ATR$C_RECATTR, &recattr },
|
|
|
|
|
{ ATR$S_ASCNAME, ATR$C_ASCNAME, &ascnamebuff },
|
|
|
|
|
{ 0, 0, 0}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
FIBDEF fib;
|
|
|
|
|
struct dsc$descriptor_fib fibdsc = {sizeof (fib), (void *) &fib};
|
|
|
|
|
|
|
|
|
|
struct IOSB iosb;
|
|
|
|
|
|
|
|
|
|
long status;
|
|
|
|
|
unsigned short chan;
|
|
|
|
|
|
|
|
|
|
struct vstring file;
|
|
|
|
|
struct dsc$descriptor_s filedsc
|
|
|
|
|
= {NAM$C_MAXRSS, DSC$K_DTYPE_T, DSC$K_CLASS_S, (void *) file.string};
|
|
|
|
|
struct vstring device;
|
|
|
|
|
struct dsc$descriptor_s devicedsc
|
|
|
|
|
= {NAM$C_MAXRSS, DSC$K_DTYPE_T, DSC$K_CLASS_S, (void *) device.string};
|
|
|
|
|
struct vstring result;
|
|
|
|
|
struct dsc$descriptor_s resultdsc
|
|
|
|
|
= {NAM$C_MAXRSS, DSC$K_DTYPE_VT, DSC$K_CLASS_VS, (void *) result.string};
|
|
|
|
|
|
|
|
|
|
if (strcmp (filename, "<internal>") == 0
|
|
|
|
|
|| strcmp (filename, "<built-in>") == 0)
|
|
|
|
|
{
|
|
|
|
|
if (cdt)
|
|
|
|
|
*cdt = 0;
|
|
|
|
|
|
|
|
|
|
if (siz)
|
|
|
|
|
*siz = 0;
|
|
|
|
|
|
|
|
|
|
if (rfo)
|
|
|
|
|
*rfo = 0;
|
|
|
|
|
|
|
|
|
|
if (ver)
|
|
|
|
|
*ver = 0;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tryfile = to_vms_file_spec (filename);
|
|
|
|
|
|
|
|
|
|
/* Allocate and initialize a FAB and NAM structures. */
|
|
|
|
|
fab = cc$rms_fab;
|
|
|
|
|
nam = cc$rms_nam;
|
|
|
|
|
|
|
|
|
|
nam.nam$l_esa = file.string;
|
|
|
|
|
nam.nam$b_ess = NAM$C_MAXRSS;
|
|
|
|
|
nam.nam$l_rsa = result.string;
|
|
|
|
|
nam.nam$b_rss = NAM$C_MAXRSS;
|
|
|
|
|
fab.fab$l_fna = tryfile;
|
|
|
|
|
fab.fab$b_fns = strlen (tryfile);
|
|
|
|
|
fab.fab$l_nam = &nam;
|
|
|
|
|
|
|
|
|
|
/* Validate filespec syntax and device existence. */
|
|
|
|
|
status = SYS$PARSE (&fab, 0, 0);
|
|
|
|
|
if ((status & 1) != 1)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
file.string[nam.nam$b_esl] = 0;
|
|
|
|
|
|
|
|
|
|
/* Find matching filespec. */
|
|
|
|
|
status = SYS$SEARCH (&fab, 0, 0);
|
|
|
|
|
if ((status & 1) != 1)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
file.string[nam.nam$b_esl] = 0;
|
|
|
|
|
result.string[result.length=nam.nam$b_rsl] = 0;
|
|
|
|
|
|
|
|
|
|
/* Get the device name and assign an IO channel. */
|
|
|
|
|
strncpy (device.string, nam.nam$l_dev, nam.nam$b_dev);
|
|
|
|
|
devicedsc.dsc$w_length = nam.nam$b_dev;
|
|
|
|
|
chan = 0;
|
|
|
|
|
status = SYS$ASSIGN (&devicedsc, &chan, 0, 0, 0);
|
|
|
|
|
if ((status & 1) != 1)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
/* Initialize the FIB and fill in the directory id field. */
|
|
|
|
|
memset (&fib, 0, sizeof (fib));
|
|
|
|
|
fib.fib$w_did[0] = nam.nam$w_did[0];
|
|
|
|
|
fib.fib$w_did[1] = nam.nam$w_did[1];
|
|
|
|
|
fib.fib$w_did[2] = nam.nam$w_did[2];
|
|
|
|
|
fib.fib$l_acctl = 0;
|
|
|
|
|
fib.fib$l_wcc = 0;
|
|
|
|
|
strcpy (file.string, (strrchr (result.string, ']') + 1));
|
|
|
|
|
filedsc.dsc$w_length = strlen (file.string);
|
|
|
|
|
result.string[result.length = 0] = 0;
|
|
|
|
|
|
|
|
|
|
/* Open and close the file to fill in the attributes. */
|
|
|
|
|
status
|
|
|
|
|
= SYS$QIOW (0, chan, IO$_ACCESS|IO$M_ACCESS, &iosb, 0, 0,
|
|
|
|
|
&fibdsc, &filedsc, &result.length, &resultdsc, &atrlst, 0);
|
|
|
|
|
if ((status & 1) != 1)
|
|
|
|
|
return 1;
|
|
|
|
|
if ((iosb.status & 1) != 1)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
result.string[result.length] = 0;
|
|
|
|
|
status = SYS$QIOW (0, chan, IO$_DEACCESS, &iosb, 0, 0, &fibdsc, 0, 0, 0,
|
|
|
|
|
&atrlst, 0);
|
|
|
|
|
if ((status & 1) != 1)
|
|
|
|
|
return 1;
|
|
|
|
|
if ((iosb.status & 1) != 1)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
/* Deassign the channel and exit. */
|
|
|
|
|
status = SYS$DASSGN (chan);
|
|
|
|
|
if ((status & 1) != 1)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
if (cdt) *cdt = create;
|
|
|
|
|
if (siz) *siz = (512 * 65536 * recattr.fat$w_efblkh) +
|
|
|
|
|
(512 * (recattr.fat$w_efblkl - 1)) +
|
|
|
|
|
recattr.fat$w_ffbyte;
|
|
|
|
|
if (rfo) *rfo = recattr.fat$v_rtype;
|
|
|
|
|
if (ver) *ver = strtol (strrchr (ascnamebuff, ';')+1, 0, 10);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
#else
|
|
|
|
|
struct stat buff;
|
|
|
|
|
|
|
|
|
|
if ((stat (filename, &buff)) != 0)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
if (cdt)
|
|
|
|
|
*cdt = (long long) (buff.st_mtime * VMS_GRANULARITY_FACTOR)
|
|
|
|
|
+ VMS_EPOCH_OFFSET;
|
|
|
|
|
|
|
|
|
|
if (siz)
|
|
|
|
|
*siz = buff.st_size;
|
|
|
|
|
|
|
|
|
|
if (rfo)
|
|
|
|
|
*rfo = 2; /* Stream LF format */
|
|
|
|
|
|
|
|
|
|
if (ver)
|
|
|
|
|
*ver = 1;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
#endif
|