| /* Copyright (C) 2021-2024 Free Software Foundation, Inc. |
| Contributed by Oracle. |
| |
| This file is part of GNU Binutils. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3, or (at your option) |
| any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, 51 Franklin Street - Fifth Floor, Boston, |
| MA 02110-1301, USA. */ |
| |
| #ifndef _MODULE_H |
| #define _MODULE_H |
| |
| // A Module object represents a .o file that was used to build up a segement. |
| // Its main function is to compute source and disassembly annotations |
| // Text reordering and/or function outlining imply that a module may |
| // not be contiguous. |
| |
| #include "Histable.h" |
| #include "Hist_data.h" |
| |
| #define MOD_FLAG_UNKNOWN 0x01 |
| |
| class LoadObject; |
| class MetricList; |
| class ComC; |
| class Disasm; |
| class Hist_data; |
| class Stabs; |
| class SourceFile; |
| class DataObject; |
| class JMethod; |
| template <class ITEM> class Vector; |
| |
| class InlinedSubr |
| { |
| public: |
| InlinedSubr (); |
| DbeLine *dbeLine; |
| Function *func; |
| char *fname; |
| uint64_t low_pc; |
| uint64_t high_pc; |
| int level; |
| |
| bool |
| contains (InlinedSubr *p) |
| { |
| return low_pc <= p->low_pc && high_pc >= p->high_pc; |
| } |
| |
| bool |
| contains (uint64_t pc) |
| { |
| return low_pc <= pc && high_pc > pc; |
| } |
| }; |
| |
| class Module : public HistableFile |
| { |
| public: |
| // Annotated Source or Disassembly |
| enum Anno_Errors |
| { |
| AE_OK, |
| AE_NOTREAD, |
| AE_NOSRC, |
| AE_NOOBJ, |
| AE_NOLOBJ, |
| AE_NOSTABS, |
| AE_NOSYMTAB, |
| AE_TIMESRC, |
| AE_TIMEDIS, |
| AE_TIMESTABS, |
| AE_TIMESTABS_DIFF, |
| AE_OTHER |
| }; |
| |
| // The following enums are duplicated in Java |
| enum Anno_Types |
| { |
| AT_LIST = 0, |
| AT_SRC, |
| AT_SRC_ONLY, |
| AT_DIS, |
| AT_COM, |
| AT_QUOTE, |
| AT_FUNC, |
| AT_EMPTY, |
| AT_DIS_ONLY |
| }; |
| |
| Module (); |
| virtual ~Module (); |
| virtual int64_t get_size (); |
| virtual void set_name (char *str); |
| virtual Vector<Histable*> *get_comparable_objs (); |
| virtual int readFile (); |
| |
| virtual Histable_type |
| get_type () |
| { |
| return MODULE; |
| } |
| |
| inline Anno_Errors |
| get_status () |
| { |
| return status; |
| } |
| |
| inline void |
| set_file_name (char *fnm) |
| { |
| free (file_name); |
| file_name = fnm; |
| } |
| |
| // get error string |
| char *anno_str (char *fnm = NULL); |
| |
| // generate annotated source/disassembly data |
| Hist_data *get_data (DbeView *dbev, MetricList *mlist, |
| Histable::Type type, TValue *ftotal, SourceFile *srcFile, |
| Function *func, Vector<int> *marks, int threshold, |
| int vis_bits, int src_visible, bool hex_visible, |
| bool func_scope, bool src_only, |
| Vector<int_pair_t> *marks2d = NULL, |
| Vector<int_pair_t> *marks2d_inc = NULL); |
| |
| Vector<uint64_t> *getAddrs (Function *func); |
| SourceFile *setIncludeFile (char *includeFile); |
| |
| SourceFile * |
| getIncludeFile () |
| { |
| return curr_inc; |
| } |
| |
| SourceFile * |
| getMainSrc () |
| { |
| return main_source; |
| } |
| |
| char * |
| getResolvedObjectPath () |
| { |
| return stabsPath ? stabsPath : get_name (); |
| } |
| |
| char * |
| getDebugPath () |
| { |
| setFile (); |
| return stabsPath; |
| } |
| |
| void read_stabs (bool all = true); |
| void dump_dataobjects (FILE *out); |
| DataObject *get_dobj (uint32_t dtype_id); |
| void reset_datatypes (); |
| void read_hwcprof_info (); |
| bool is_fortran (); |
| SourceFile *findSource (const char *fname, bool create); |
| bool openStabs (bool all = true); |
| LoadObject *createLoadObject (const char *lo_name); |
| JMethod *find_jmethod (const char *nm, const char *sig); |
| |
| unsigned int flags; // flags used for marking traversals |
| Sp_lang_code lang_code; // What is source lang. in module |
| char *file_name; // Full path to actual source file |
| Vector<Function*> *functions; // Unordered list of functions |
| LoadObject *loadobject; // Parent loadobject |
| LoadObject *dot_o_file; // The .o file with debug information |
| unsigned fragmented; // -xF used when compiling module |
| int real_timestamp; // Linked timestamp from N_OPT stab |
| int curr_timestamp; // Current object timestamp from N_OPT stab |
| char *comp_flags; // compiler flags used to compile module |
| char *comp_dir; // directory used to compile module |
| char *linkerStabName; // Name from 'N_UNDF' stab |
| Stabs *objStabs; // stabs of object file |
| bool readStabs; |
| bool hasStabs; |
| bool hasDwarf; |
| uint64_t hdrOffset; // offset in .debug_info |
| unsigned hwcprof; // hwcprof info status |
| Vector<inst_info_t*> *infoList; // merged list |
| Vector<memop_info_t*> ldMemops; // load instructions |
| Vector<memop_info_t*> stMemops; // store instructions |
| Vector<memop_info_t*> pfMemops; // prefetch instructions |
| Vector<target_info_t*> bTargets; // branch targets |
| Vector<datatype_t*> *datatypes; // object type descriptors |
| Vector<SourceFile*> *includes; |
| Module *indexStabsLink; // correspondent module for the .o file |
| InlinedSubr *inlinedSubr; |
| |
| protected: |
| void removeStabsTmp (); // Remove temporary *.o (got from *.a) |
| |
| // Check timestamp, warn users if src/dis/stabs later than exp. |
| Anno_Errors checkTimeStamp (bool chkDis); |
| |
| // Set paths for reading Stabs and Symbols |
| bool read_ar (int ar, int obj, char *obj_base); |
| bool setFile (); |
| |
| // Open appropriate symbol tables, construct set of PC ranges, |
| // and maps to source lines for each PC |
| Stabs *openDebugInfo (); |
| |
| // Construct PC index table |
| bool openDisPC (); |
| |
| // Compute data--scan data to compute metrics per-src-line/dis-line |
| bool computeMetrics (DbeView *dbev, Function *func, MetricList *mlist, |
| Histable::Type type, bool src_metric, |
| bool func_scope, SourceFile *source); |
| void init_line (); |
| void init_index (Hist_data *witems, int &wlindex, int &wmsize, int &wmindex); |
| |
| void set_src_data (Function *func, int vis_bits, int cmpline_visible, |
| int funcline_visible); |
| void set_dis_data (Function *func, int vis_bits, int cmpline_visible, |
| int src_visible, bool hex_vis, bool func_scope, |
| int funcline_visible); |
| void set_src (Anno_Types type, DbeLine *dbeline); |
| void set_dis (DbeInstr *instr, Anno_Types type, bool nextFile, char *dis_str); |
| void set_MPSlave (); |
| void set_one (Hist_data::HistItem *org_item, Anno_Types type, const char *text); |
| void set_ComCom (int vis_bits); |
| |
| virtual char *get_disasm (uint64_t inst_address, uint64_t end_address, |
| uint64_t start_address, uint64_t f_offset, |
| int64_t &inst_size); |
| |
| Anno_Errors status; |
| Anno_Errors openSourceFlag; |
| bool hexVisible; // show hex code in disasm |
| time_t disMTime; // Creating time for disassembly |
| time_t stabsMTime; // Creating time for stabs |
| SourceFile *main_source; |
| SourceFile *curr_inc; // pointer to include file or NULL |
| SourceFile *srcContext; |
| Vector<ComC*> *comComs; // table of compiler comments |
| Disasm *disasm; |
| Hist_data *src_items; |
| Hist_data *dis_items; |
| Hist_data *data_items; |
| DbeView * cur_dbev; |
| TValue *total; |
| TValue *maximum; |
| TValue *maximum_inc; |
| TValue *empty; |
| int name_idx; // index of name metric in list for src/dis |
| int size_index; // index of size metric in list for src/dis |
| int addr_index; // index of address metric in list for src/dis |
| |
| int curline; // line# of next source line to be processed |
| int cindex, cline; // index and src line of next compiler-comment |
| int sindex, sline; // index and src line of next item in src_items |
| int dindex; |
| DbeInstr *daddr; // pointer to next DbeInstr with metrics |
| int mindex; // MP index and src line of next metric-value |
| int mline; // MP line to be processed by source |
| |
| char *disPath; // path for disassembly |
| char *stabsPath; // path for reading stabs |
| char *stabsTmp; // temporary *.o from *.a |
| char *disName; // library/path for disassembly |
| char *stabsName; // library/path for stabs |
| }; |
| |
| #endif /* _MODULE_H */ |