/* Copyright (C) 2021-2026 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 */