diff --git a/Plugins/HelloWorldPlugin/HelloWorldPlugin.cpp b/Plugins/HelloWorldPlugin/HelloWorldPlugin.cpp
index 383da5518..a6bb9d904 100644
--- a/Plugins/HelloWorldPlugin/HelloWorldPlugin.cpp
+++ b/Plugins/HelloWorldPlugin/HelloWorldPlugin.cpp
@@ -11,6 +11,9 @@
 #include <iostream>
 
 class DLL_A_EXPORT HelloWorldPlugin : public eld::plugin::LinkerPlugin {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   HelloWorldPlugin() : eld::plugin::LinkerPlugin("HelloWorldPlugin") {}
 
diff --git a/include/eld/BranchIsland/BranchIsland.h b/include/eld/BranchIsland/BranchIsland.h
index 9356c4049..e24c70af3 100644
--- a/include/eld/BranchIsland/BranchIsland.h
+++ b/include/eld/BranchIsland/BranchIsland.h
@@ -33,6 +33,9 @@ class Relocation;
  *
  */
 class BranchIsland {
+public:
+  static std::string getTypeName() { return "BranchIsland"; }
+
 public:
   typedef std::vector<Relocation *> RelocationListType;
   typedef RelocationListType::iterator reloc_iterator;
diff --git a/include/eld/BranchIsland/BranchIslandFactory.h b/include/eld/BranchIsland/BranchIslandFactory.h
index e3adf01bf..a525dd7f7 100644
--- a/include/eld/BranchIsland/BranchIslandFactory.h
+++ b/include/eld/BranchIsland/BranchIslandFactory.h
@@ -31,6 +31,9 @@ class FragmentRef;
  *
  */
 class BranchIslandFactory {
+public:
+  static std::string getTypeName() { return "BranchIslandFactory"; }
+
 public:
   BranchIslandFactory(bool UseAddends, LinkerConfig &Config);
 
diff --git a/include/eld/BranchIsland/StubFactory.h b/include/eld/BranchIsland/StubFactory.h
index ef37e699d..4effe2ca7 100644
--- a/include/eld/BranchIsland/StubFactory.h
+++ b/include/eld/BranchIsland/StubFactory.h
@@ -31,6 +31,9 @@ class IRBuilder;
  *
  */
 class StubFactory {
+public:
+  static std::string getTypeName() { return "StubFactory"; }
+
 public:
   typedef std::vector<Stub *> StubVector;
   StubFactory(Stub *TargetStub);
diff --git a/include/eld/Config/GeneralOptions.h b/include/eld/Config/GeneralOptions.h
index 4faed78b0..02ec406a7 100644
--- a/include/eld/Config/GeneralOptions.h
+++ b/include/eld/Config/GeneralOptions.h
@@ -43,6 +43,9 @@ class ZOption;
  *     - attribute of input files
  */
 class GeneralOptions {
+public:
+  static std::string getTypeName() { return "GeneralOptions"; }
+
 public:
   typedef llvm::StringMap<std::string> SymbolRenameMap;
 
@@ -834,6 +837,16 @@ class GeneralOptions {
   void setTimingStatsFile(std::string StatsFile) {
     TimingStatsFile = StatsFile;
   }
+  //--------------------Memory Report--------------------------------
+  // --print-memory-report
+  bool showMemoryReport() const { return PrintMemoryReport; }
+
+  void setPrintMemoryReport() { PrintMemoryReport = true; }
+
+  // --emit-memory-report <file>
+  std::string getMemoryReportFile() const { return MemoryReportFile; }
+
+  void setMemoryReportFile(std::string F) { MemoryReportFile = F; }
   //--------------------Plugin Config--------------------------------
   void addPluginConfig(const std::string &Config) {
     PluginConfig.push_back(Config);
@@ -1233,6 +1246,7 @@ class GeneralOptions {
   bool BExecuteOnly = false;              // --execute-only
   bool BPrintTimeStats = false;           // --print-stats
   bool BPrintAllUserPluginTimeStats = false;
+  bool PrintMemoryReport = false;         // --print-memory-report
   bool BDemangle = true;                  // --demangle-style
   bool ValidateArchOpts = false;          // check -mabi with backend
   bool DisableGuardForWeakUndefs = false; // hexagon specific option to
@@ -1265,7 +1279,8 @@ class GeneralOptions {
   std::string Filter;
   std::string MapFile; // Mapfile
   std::string TarFile; // --reproduce output tarfile name
-  std::string TimingStatsFile;
+  std::string TimingStatsFile;           // --emit-timing-stats
+  std::string MemoryReportFile;          // --emit-memory-report
   std::string MappingFileName;           // --Mapping-file
   std::string MappingDumpFile;           // --dump-mapping-file
   std::string ResponseDumpFile;          // --dump-response-file
diff --git a/include/eld/Config/LinkerConfig.h b/include/eld/Config/LinkerConfig.h
index 866df4fb5..c6c2013f0 100644
--- a/include/eld/Config/LinkerConfig.h
+++ b/include/eld/Config/LinkerConfig.h
@@ -34,6 +34,9 @@ class Module;
 class DiagnosticEngine;
 class SearchDirs;
 class LinkerConfig {
+public:
+  static std::string getTypeName() { return "LinkerConfig"; }
+
 public:
   enum CodeGenType { Unknown, Object, DynObj, Exec, External, Binary };
 
@@ -75,6 +78,8 @@ class LinkerConfig {
   enum SymDefStyle { Default, Provide, UnknownSymDefStyle };
 
   struct WarnOptions {
+  public:
+    static std::string getTypeName() { return "WarnOptions"; }
     std::optional<bool> EnableAllWarnings;
     std::optional<bool> EnableLinkerScriptWarnings;
     std::optional<bool> EnableZeroSizedSectionsWarnings;
@@ -88,6 +93,8 @@ class LinkerConfig {
   };
 
   struct MappingFileInfo {
+  public:
+    static std::string getTypeName() { return "MappingFileInfo"; }
     std::unordered_map<std::string, std::string> StringMapKeyToValue;
 
     void addStringMapEntry(llvm::StringRef Key, llvm::StringRef Value) {
diff --git a/include/eld/Config/TargetOptions.h b/include/eld/Config/TargetOptions.h
index 0295ae18e..a22085598 100644
--- a/include/eld/Config/TargetOptions.h
+++ b/include/eld/Config/TargetOptions.h
@@ -26,6 +26,9 @@ class LinkerScript;
  *  backend.
  */
 class TargetOptions {
+public:
+  static std::string getTypeName() { return "TargetOptions"; }
+
 public:
   enum Endian { Little, Big, Unknown };
 
diff --git a/include/eld/Core/CommandLine.h b/include/eld/Core/CommandLine.h
index b0c58f81b..4a873cb49 100644
--- a/include/eld/Core/CommandLine.h
+++ b/include/eld/Core/CommandLine.h
@@ -11,6 +11,9 @@
 namespace eld {
 
 struct CommandLine {
+public:
+  static std::string getTypeName() { return "CommandLine"; }
+
 public:
   typedef enum { Flag, Option, MultiValueOption } CmdType;
 
@@ -23,6 +26,8 @@ struct CommandLine {
 };
 
 struct Flags : public CommandLine {
+public:
+  static std::string getTypeName() { return "Flags"; }
   Flags(const std::string &Opt, bool Flag)
       : CommandLine(CmdType::Flag), Option(Opt), Flag(Flag) {}
 
@@ -39,6 +44,8 @@ struct Flags : public CommandLine {
 };
 
 struct Options : public CommandLine {
+public:
+  static std::string getTypeName() { return "Options"; }
   Options(const std::string &Opt, const std::string &Arg)
       : CommandLine(CmdType::Option), Option(Opt), Argument(Arg) {}
 
@@ -55,6 +62,8 @@ struct Options : public CommandLine {
 };
 
 struct MultiValueOption : public CommandLine {
+public:
+  static std::string getTypeName() { return "MultiValueOption"; }
   MultiValueOption(const std::string &Opt, const std::vector<std::string> &Arg)
       : CommandLine(CmdType::MultiValueOption), Option(Opt), ArgumentList(Arg) {
   }
diff --git a/include/eld/Core/Linker.h b/include/eld/Core/Linker.h
index db103334d..038b7ecd8 100644
--- a/include/eld/Core/Linker.h
+++ b/include/eld/Core/Linker.h
@@ -40,6 +40,9 @@ class ObjectLinker;
  *  \brief Linker is a modular linker.
  */
 class Linker {
+public:
+  static std::string getTypeName() { return "Linker"; }
+
 public:
   enum UnresolvedPolicy {
     NotSet = 0x0,
diff --git a/include/eld/Core/LinkerScript.h b/include/eld/Core/LinkerScript.h
index 31e031e8c..ebbd45b5d 100644
--- a/include/eld/Core/LinkerScript.h
+++ b/include/eld/Core/LinkerScript.h
@@ -55,6 +55,9 @@ class MemoryCmd;
 class SymbolContainer;
 
 class Phdrs {
+public:
+  static std::string getTypeName() { return "Phdrs"; }
+
 public:
   Phdrs(const PhdrSpec &PPhdrDesc) {
     ScriptSpec.Name = PPhdrDesc.Name;
@@ -77,6 +80,9 @@ class Phdrs {
  *
  */
 class LinkerScript {
+public:
+  static std::string getTypeName() { return "LinkerScript"; }
+
 public:
   typedef std::vector<Assignment *> Assignments;
   typedef std::vector<ChangeOutputSectionPluginOp *> OverrideSectionMatchT;
diff --git a/include/eld/Core/Module.h b/include/eld/Core/Module.h
index 3343daa10..ef48cafcb 100644
--- a/include/eld/Core/Module.h
+++ b/include/eld/Core/Module.h
@@ -71,6 +71,9 @@ class ScriptSymbol;
  *  \brief Module provides the intermediate representation for linking.
  */
 class Module {
+public:
+  static std::string getTypeName() { return "Module"; }
+
 public:
   typedef enum {
     Attributes,
diff --git a/include/eld/Diagnostics/Diagnostic.h b/include/eld/Diagnostics/Diagnostic.h
index 96f5fb65d..1131ccfc1 100644
--- a/include/eld/Diagnostics/Diagnostic.h
+++ b/include/eld/Diagnostics/Diagnostic.h
@@ -25,6 +25,9 @@ namespace eld {
  *  \brief Diagnostic provides current status to DiagnosticPrinters.
  */
 class Diagnostic {
+public:
+  static std::string getTypeName() { return "Diagnostic"; }
+
 public:
   Diagnostic(DiagnosticEngine &PEngine);
 
diff --git a/include/eld/Diagnostics/DiagnosticEngine.h b/include/eld/Diagnostics/DiagnosticEngine.h
index ac94bb033..523ab8e46 100644
--- a/include/eld/Diagnostics/DiagnosticEngine.h
+++ b/include/eld/Diagnostics/DiagnosticEngine.h
@@ -89,6 +89,9 @@ using DiagnosticEntry = plugin::DiagnosticEntry;
  * maintain thread-safety of diagnostic functions.
  */
 class DiagnosticEngine {
+public:
+  static std::string getTypeName() { return "DiagnosticEngine"; }
+
 public:
   enum Severity {
     // None must be 0 because currently 0 severity value represent
@@ -161,6 +164,9 @@ class DiagnosticEngine {
   };
 
   struct State {
+  public:
+    static std::string getTypeName() { return "State"; }
+
   public:
     State() = default;
     ~State() {}
@@ -282,6 +288,8 @@ class DiagnosticEngine {
 };
 
 class Diag {
+public:
+  static std::string getTypeName() { return "Diag"; }
   static DiagnosticEngine::DiagIDType Counter;
 
 public:
diff --git a/include/eld/Diagnostics/DiagnosticInfos.h b/include/eld/Diagnostics/DiagnosticInfos.h
index 763db4dd1..a4f56dd80 100644
--- a/include/eld/Diagnostics/DiagnosticInfos.h
+++ b/include/eld/Diagnostics/DiagnosticInfos.h
@@ -31,9 +31,15 @@ class DiagnosticEngine;
  * for the outside world.
  */
 class DiagnosticInfos {
+public:
+  static std::string getTypeName() { return "DiagnosticInfos"; }
+
 public:
   /// Stores custom diagnostic info
   class CustomDiagInfo {
+  public:
+    static std::string getTypeName() { return "CustomDiagInfo"; }
+
   public:
     CustomDiagInfo(const std::string &PFormatStr) : FormatStr(PFormatStr) {}
     llvm::StringRef getDescription() const { return FormatStr; }
diff --git a/include/eld/Diagnostics/DiagnosticPrinter.h b/include/eld/Diagnostics/DiagnosticPrinter.h
index 0a938566d..81d35b205 100644
--- a/include/eld/Diagnostics/DiagnosticPrinter.h
+++ b/include/eld/Diagnostics/DiagnosticPrinter.h
@@ -27,6 +27,9 @@ namespace eld {
  *  messages and output.
  */
 class DiagnosticPrinter {
+public:
+  static std::string getTypeName() { return "DiagnosticPrinter"; }
+
 public:
   enum TraceType {
     TraceFiles = 0x1,
diff --git a/include/eld/Diagnostics/MsgHandler.h b/include/eld/Diagnostics/MsgHandler.h
index 9e42ac8fe..c031c29e5 100644
--- a/include/eld/Diagnostics/MsgHandler.h
+++ b/include/eld/Diagnostics/MsgHandler.h
@@ -47,6 +47,9 @@ namespace eld {
  *  \brief MsgHandler controls the timing to output message.
  */
 class MsgHandler {
+public:
+  static std::string getTypeName() { return "MsgHandler"; }
+
 public:
   MsgHandler(DiagnosticEngine &PEngine, std::unique_lock<std::timed_mutex> Lock);
   ~MsgHandler();
diff --git a/include/eld/Driver/ARMLinkDriver.h b/include/eld/Driver/ARMLinkDriver.h
index aae63035d..d55c45319 100644
--- a/include/eld/Driver/ARMLinkDriver.h
+++ b/include/eld/Driver/ARMLinkDriver.h
@@ -20,6 +20,9 @@ class DiagnosticEngine;
 
 // Create OptTable class for parsing actual command line arguments
 class OPT_ARMLinkOptTable : public llvm::opt::GenericOptTable {
+public:
+  static std::string getTypeName() { return "OPT_ARMLinkOptTable"; }
+
 public:
   enum {
     INVALID = 0,
@@ -35,6 +38,9 @@ class OPT_ARMLinkOptTable : public llvm::opt::GenericOptTable {
 };
 
 class ARMLinkDriver : public GnuLdDriver {
+public:
+  static std::string getTypeName() { return "ARMLinkDriver"; }
+
 public:
   static ARMLinkDriver *Create(eld::LinkerConfig &C,
                                std::string InferredArchFromProgramName);
diff --git a/include/eld/Driver/Driver.h b/include/eld/Driver/Driver.h
index 3bd4ee080..7e8ef9c06 100644
--- a/include/eld/Driver/Driver.h
+++ b/include/eld/Driver/Driver.h
@@ -28,6 +28,9 @@ class DiagnosticEngine;
 class GnuLdDriver;
 
 class DLL_A_EXPORT Driver {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   Driver(DriverFlavor F = DriverFlavor::Invalid);
 
diff --git a/include/eld/Driver/GnuLdDriver.h b/include/eld/Driver/GnuLdDriver.h
index 4d514f1fe..1da017a86 100644
--- a/include/eld/Driver/GnuLdDriver.h
+++ b/include/eld/Driver/GnuLdDriver.h
@@ -35,6 +35,9 @@ class LinkerScript;
 
 // Create OptTable class for parsing actual command line arguments
 class OPT_GnuLdOptTable : public llvm::opt::GenericOptTable {
+public:
+  static std::string getTypeName() { return "OPT_GnuLdOptTable"; }
+
 public:
   enum {
     INVALID = 0,
@@ -50,6 +53,9 @@ class OPT_GnuLdOptTable : public llvm::opt::GenericOptTable {
 };
 
 class DLL_A_EXPORT GnuLdDriver {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   static GnuLdDriver *Create(eld::LinkerConfig &C, DriverFlavor F,
                              std::string InferredArchFromProgramName);
@@ -160,6 +166,8 @@ class DLL_A_EXPORT GnuLdDriver {
 
   void setDriverFlavor(DriverFlavor F) { m_DriverFlavor = F; }
 
+  bool emitMemoryReport() const;
+
 private:
   // Raise diag entry for trace.
   bool checkAndRaiseTraceDiagEntry(eld::Expected<void> E) const;
diff --git a/include/eld/Driver/GnuLinkerOptions.td b/include/eld/Driver/GnuLinkerOptions.td
index dc7ddd959..659e3bb1e 100644
--- a/include/eld/Driver/GnuLinkerOptions.td
+++ b/include/eld/Driver/GnuLinkerOptions.td
@@ -6,11 +6,11 @@
 
 include "llvm/Option/OptParser.td"
 
-//===----------------------------------------------------------------------===//
-/// Utility Functions
-//===----------------------------------------------------------------------===//
-// Single and multiple dash options combined
-multiclass smDash<string opt1, string opt2, string help> {
+    //===----------------------------------------------------------------------===//
+    /// Utility Functions
+    //===----------------------------------------------------------------------===//
+    // Single and multiple dash options combined
+    multiclass smDash<string opt1, string opt2, string help> {
   // Option
   def "" : Separate<["-"], opt1>, HelpText<help>;
   def opt1_eq : Joined<["-"], opt1 #"=">, Alias<!cast<Option>(opt1)>;
@@ -73,9 +73,10 @@ multiclass mDashEq<string opt1, string realopt, string help> {
 
 // --<option>,--<option>=
 multiclass EEq<string name, string help> {
-  def NAME: Separate<["--"], name>;
-  def NAME # _eq: Joined<["--"], name # "=">, Alias<!cast<Separate>(NAME)>,
-    HelpText<help>;
+  def NAME : Separate<["--"], name>;
+  def NAME #_eq : Joined<["--"], name #"=">,
+                  Alias<!cast<Separate>(NAME)>,
+                  HelpText<help>;
 }
 
 // Support -<option>,-<option>=
@@ -98,17 +99,18 @@ multiclass
 }
 
 // Support -<option>=,--<option>=
-multiclass smDashOnlyEq<string opt1, string realopt, string help> {
-  def "" : Joined<["-"], opt1 #"=">, HelpText<help>;
-  def opt1_eq : Joined<["--"], opt1 #"=">, Alias<!cast<Option>(realopt)>;
+multiclass smDashOnlyEq<string opt1, string realopt, string help>{
+  def "" : Joined<["-"], opt1 #"=">,
+  HelpText<help>;
+def opt1_eq : Joined<["--"], opt1 #"=">, Alias<!cast<Option>(realopt)>;
 }
 
 // Support -<option>=,--<option>= aliases
 multiclass smDashOnlyEqAlias<string opt1, string realopt, string help> {
-  def "" : Joined<["-"], opt1#"=">,
+  def "" : Joined<["-"], opt1 #"=">,
            Alias<!cast<Option>(realopt)>,
            HelpText<help>;
-  def opt1_eq : Joined<["--"], opt1#"=">,
+  def opt1_eq : Joined<["--"], opt1 #"=">,
                 Alias<!cast<Option>(realopt)>,
                 HelpText<help>;
 }
@@ -122,7 +124,7 @@ defm output_file : smDashTwoWithOpt<"o", "output", "output_file",
                    MetaVarName<"<outputfile>">,
                    Group<grp_general>;
 defm sysroot : smDash<"sysroot", "sysroot", "Set the system root">,
-              MetaVarName<"<sysroot-path>">,
+               MetaVarName<"<sysroot-path>">,
                Group<grp_general>;
 def version : Flag<["--"], "version">,
               HelpText<"Print the Linker version">,
@@ -138,7 +140,7 @@ defm build_id_val
     : smDashOnlyEq<
           "build-id", "build_id_val",
           "Request creation of \".note.gnu.build-id\" ELF note section">,
-           MetaVarName<"fast/md5/sha1/tree/uuid/0x<hexstring>/none">,
+      MetaVarName<"fast/md5/sha1/tree/uuid/0x<hexstring>/none">,
       Group<grp_general>;
 
 //===----------------------------------------------------------------------===//
@@ -253,7 +255,7 @@ defm exclude_libs : mDashEq<"exclude-libs", "exclude_libs",
                     MetaVarName<"<libs>">,
                     Group<grp_scriptopts>;
 def unique_output_sections
-    : Flag<["-", "--"], "unique-output-sections">,
+    : Flag<[ "-", "--" ], "unique-output-sections">,
       HelpText<"Place each input section in a unique output section">,
       Group<grp_scriptopts>;
 def global_merge_non_alloc_strings
@@ -270,7 +272,8 @@ def enable_overlap_checks
       Group<grp_scriptopts>;
 def print_memory_usage
     : Flag<["--"], "print-memory-usage">,
-      HelpText<"Print memory usage when MEMORY linker script directive is used">,
+      HelpText<
+          "Print memory usage when MEMORY linker script directive is used">,
       Group<grp_scriptopts>;
 
 //===----------------------------------------------------------------------===//
@@ -281,8 +284,8 @@ def relocatable : Flag<["-"], "r">,
                   HelpText<"Create relocatable object file">,
                   Group<grp_kind>;
 def static_link : Flag<["-"], "static">,
-             HelpText<"Create static executable">,
-             Group<grp_kind>;
+                  HelpText<"Create static executable">,
+                  Group<grp_kind>;
 def dynamic : Flag<["-"], "dynamic">,
               HelpText<"Create dynamic executable (default)">,
               Group<grp_kind>;
@@ -293,8 +296,8 @@ def pie : Flag<["-"], "pie">,
           HelpText<"Create PIE executable">,
           Group<grp_kind>;
 def no_pie : Flag<["-"], "no-pie">,
-          HelpText<"Do not create a PIE executable">,
-          Group<grp_kind>;
+             HelpText<"Do not create a PIE executable">,
+             Group<grp_kind>;
 def picexec : Flag<["--"], "pic-executable">,
               Group<grp_kind>,
               HelpText<"Create PIE executable">,
@@ -343,11 +346,10 @@ def namespec : Joined<["--"], "library=">,
                MetaVarName<"<namespec>">,
                HelpText<"library to use">,
                Group<grp_main>;
-defm library_path
-    : mDashEq<"library-path", "library_path",
-              "Path to search for libraries or linker scripts">,
-      MetaVarName<"<path>">,
-      Group<grp_main>;
+defm library_path : mDashEq<"library-path", "library_path",
+                            "Path to search for libraries or linker scripts">,
+                    MetaVarName<"<path>">,
+                    Group<grp_main>;
 defm Y : smDash<"Y", "Y", "Add path to the default library search path">,
          MetaVarName<"<path>">,
          Group<grp_main>;
@@ -370,17 +372,17 @@ defm init : smDash<"init", "init", "Specify an initializer function">,
 defm fini : smDash<"fini", "fini", "Specify a finalizer function">,
             MetaVarName<"<symbol>">,
             Group<grp_main>;
-def whole_archive : Flag<["-", "--"], "whole-archive">,
+def whole_archive : Flag<[ "-", "--" ], "whole-archive">,
                     HelpText<"Force load of all members in a static library">,
                     Group<grp_main>;
 def no_whole_archive
-    : Flag<["-", "--"], "no-whole-archive">,
+    : Flag<[ "-", "--" ], "no-whole-archive">,
       HelpText<"Restores the default behavior of loading archive members">,
       Group<grp_main>;
 def nostdlib : Flag<["-"], "nostdlib">,
                HelpText<"Disable default search path for libraries">,
                Group<grp_main>;
-def emit_relocs : Flag<["-", "--"], "emit-relocs">,
+def emit_relocs : Flag<[ "-", "--" ], "emit-relocs">,
                   HelpText<"Make Emit relocs behave just like GNU.">,
                   Group<grp_main>;
 def omagic
@@ -411,20 +413,19 @@ defm dynamic_linker : smDashWithOpt<"dynamic-linker", "dynamic_linker",
                                     "Set the path to the dynamic linker">,
                       MetaVarName<"<path>">,
                       Group<grp_dynlibexec>;
-defm rpath : smDash<"rpath", "rpath",
-                    "Add a path to the runtime library search path">,
-             MetaVarName<"<path>">,
-             Group<grp_dynlibexec>;
-defm rpath_link
-    : dashEqWithOpt<"rpath-link", "rpath-link", "rpath_link",
-                    "Specifies the path to search">,
+defm rpath
+    : smDash<"rpath", "rpath", "Add a path to the runtime library search path">,
       MetaVarName<"<path>">,
       Group<grp_dynlibexec>;
-def export_dynamic : Flag<["-", "--"], "export-dynamic">,
+defm rpath_link : dashEqWithOpt<"rpath-link", "rpath-link", "rpath_link",
+                                "Specifies the path to search">,
+                  MetaVarName<"<path>">,
+                  Group<grp_dynlibexec>;
+def export_dynamic : Flag<[ "-", "--" ], "export-dynamic">,
                      HelpText<"Add all symbols to the dynamic symbol table"
                               " when creating executables">,
                      Group<grp_dynlibexec>;
-def force_dynamic : Flag<["-", "--"], "force-dynamic">,
+def force_dynamic : Flag<[ "-", "--" ], "force-dynamic">,
                     HelpText<"Build executable as a force dynamic executable">,
                     Group<grp_dynlibexec>;
 def alias_export_dynamic : Flag<["-"], "E">,
@@ -439,21 +440,21 @@ defm export_dynamic_symbol
                     "Export specified symbol to dynamic symbol table">,
       MetaVarName<"<symbol>">,
       Group<grp_dynlibexec>;
-def no_dynamic_linker : Flag<["-", "--"], "no-dynamic-linker">,
-                     HelpText<"The program does not need a dynamic linker"
-                              " when creating static PIE executables">,
-                     Group<grp_dynlibexec>;
+def no_dynamic_linker : Flag<[ "-", "--" ], "no-dynamic-linker">,
+                        HelpText<"The program does not need a dynamic linker"
+                                 " when creating static PIE executables">,
+                        Group<grp_dynlibexec>;
 
 //===----------------------------------------------------------------------===//
 /// Dynamic Library Options
 //===----------------------------------------------------------------------===//
 def grp_dynlib : OptionGroup<"opts">, HelpText<"DYNAMIC LIBRARY OPTIONS">;
-def soname : Joined<["-", "--"], "soname=">,
+def soname : Joined<[ "-", "--" ], "soname=">,
              HelpText<"Set the internal DT_SONAME field to the specified name">,
              MetaVarName<"<name>">,
              Group<grp_dynlib>;
 def soname_separate
-    : Separate<["-", "--"], "soname">,
+    : Separate<[ "-", "--" ], "soname">,
       HelpText<"Set the internal DT_SONAME field to the specified name">,
       Alias<soname>,
       MetaVarName<"<name>">,
@@ -517,14 +518,14 @@ def u_alias : Joined<["--"], "undefined=">,
               MetaVarName<"<symbol>">,
               Group<grp_resolveropt>,
               Alias<u>;
-def start_group : Flag<["-", "--"], "start-group">,
+def start_group : Flag<[ "-", "--" ], "start-group">,
                   HelpText<"Start a group">,
                   Group<grp_resolveropt>;
 def alias_start_group : Flag<["-"], "(">,
                         HelpText<"Start a group">,
                         Group<grp_resolveropt>,
                         Alias<start_group>;
-def end_group : Flag<["-", "--"], "end-group">,
+def end_group : Flag<[ "-", "--" ], "end-group">,
                 HelpText<"End a group">,
                 Group<grp_resolveropt>;
 def alias_end_group : Flag<["-"], ")">,
@@ -539,13 +540,15 @@ def no_as_needed : Flag<["--"], "no-as-needed">,
                    HelpText<"This option restores the default behavior"
                             " of adding DT_NEEDED entries">,
                    Group<grp_resolveropt>;
-def push_state : Flag<["--"], "push-state">,
-                 HelpText<"Save current input handling flags (as-needed, whole-archive, etc)">,
-                 Group<grp_resolveropt>;
+def push_state
+    : Flag<["--"], "push-state">,
+      HelpText<
+          "Save current input handling flags (as-needed, whole-archive, etc)">,
+      Group<grp_resolveropt>;
 def pop_state : Flag<["--"], "pop-state">,
                 HelpText<"Restore previously saved input handling flags">,
                 Group<grp_resolveropt>;
-def allow_shlib_undefs : Flag<["-", "--"], "allow-shlib-undefined">,
+def allow_shlib_undefs : Flag<[ "-", "--" ], "allow-shlib-undefined">,
                          HelpText<"Allow undefined symbols from dynamic"
                                   " library when creating executables">,
                          Group<grp_resolveropt>;
@@ -562,7 +565,7 @@ defm defsym : smDash<"defsym", "defsym",
               MetaVarName<"symbol=<expression>">,
               Group<grp_resolveropt>;
 def no_undefined
-    : Flag<["-", "--"], "no-undefined">,
+    : Flag<[ "-", "--" ], "no-undefined">,
       HelpText<"Report unresolved symbol references from regular object files">,
       Group<grp_resolveropt>;
 def warn_once : Flag<["--"], "warn-once">,
@@ -576,10 +579,11 @@ defm unresolved_symbols
           "report-all(Default), ignore-in-object-files, ignore-in-shared-libs">,
       MetaVarName<"<option>">,
       Group<grp_scriptopts>;
-defm sort_section : EEq<"sort-section",
-                       "Sort sections. Options available are name , alignment">,
-                       MetaVarName<"<sort_section>">,
-                        Group<grp_scriptopts>;
+defm sort_section
+    : EEq<"sort-section",
+          "Sort sections. Options available are name , alignment">,
+      MetaVarName<"<sort_section>">,
+      Group<grp_scriptopts>;
 
 //===----------------------------------------------------------------------===//
 /// Symbol options
@@ -641,12 +645,14 @@ def dp : Flag<["-"], "dp">,
          HelpText<"Assign space to common symbols">,
          Alias<d>;
 def sort_common : Flag<["--"], "sort-common">,
-         HelpText<"sort common symbols by alignment">,
-         Group<grp_symbolopts>;
-defm sort_common_val : smDashOnlyEq<"sort-common", "sort_common_val",
-                       "Sort common symbols by ascdending/descending order of alignment">,
-                       MetaVarName<"<option>">,
-                        Group<grp_symbolopts>;
+                  HelpText<"sort common symbols by alignment">,
+                  Group<grp_symbolopts>;
+defm sort_common_val
+    : smDashOnlyEq<
+          "sort-common", "sort_common_val",
+          "Sort common symbols by ascdending/descending order of alignment">,
+      MetaVarName<"<option>">,
+      Group<grp_symbolopts>;
 
 //===----------------------------------------------------------------------===//
 /// Diagnostic options
@@ -678,15 +684,15 @@ defm trace
       MetaVarName<"<trace-type>">,
       Group<grp_diagopts>;
 defm trace_symbol : smDashTwoWithOpt<"y", "trace-symbol", "trace_symbol",
-                                  "Trace a particular symbol">,
+                                     "Trace a particular symbol">,
                     MetaVarName<"<symbol>">,
                     Group<grp_diagopts>;
 def trace_lto : Flag<["--"], "trace-lto">,
                 HelpText<"Trace stages of lto">,
                 Group<grp_diagopts>;
 def trace_linker_script : Flag<["--"], "trace-linker-script">,
-                HelpText<"Trace stages of linker script processing">,
-                Group<grp_diagopts>;
+                          HelpText<"Trace stages of linker script processing">,
+                          Group<grp_diagopts>;
 defm trace_section : smDashWithOpt<"trace-section", "trace_section",
                                    "Show metadata about a particular section">,
                      MetaVarName<"<section_name>">,
@@ -696,7 +702,8 @@ defm trace_reloc : smDashWithOpt<"trace-reloc", "trace_reloc",
                    MetaVarName<"<relocation>">,
                    Group<grp_diagopts>;
 defm trace_merge_strings
-    : smDashWithOpt<"trace-merge-strings", "trace_merge_strings",
+    : smDashWithOpt<
+          "trace-merge-strings", "trace_merge_strings",
           "Emit diagnostics describing how strings were merged. Options: "
           "all(default), allocatable_sections, <output section (regex)>">,
       MetaVarName<"<option>">,
@@ -709,7 +716,7 @@ defm verify_options : smDashWithOpt<"verify-options", "verify_options",
 def dash_t : Flag<["-"], "t">,
              HelpText<"Print all files processed by the linker">,
              Group<grp_diagopts>;
-def cref : Flag<["-", "--"], "cref">,
+def cref : Flag<[ "-", "--" ], "cref">,
            HelpText<"Print the references for a symbol or section">,
            Group<grp_diagopts>;
 defm emit_timing_stats : mDashEq<"emit-timing-stats", "emit_timing_stats",
@@ -719,23 +726,24 @@ defm emit_timing_stats : mDashEq<"emit-timing-stats", "emit_timing_stats",
                          Group<grp_diagopts>;
 
 def emit_timing_stats_in_output
-    : Flag<["-", "--"], "emit-timing-stats-in-output">,
+    : Flag<[ "-", "--" ], "emit-timing-stats-in-output">,
       HelpText<"Insert link-time stats in section .note.qc.timing">,
       Group<grp_diagopts>;
 
-defm time_region : mDashEq<"time-region", "time_region",
-                   "Emit time statistics for specified region of linker operation ">,
-                            MetaVarName<"<region>">,
-                             Group<grp_diagopts>;
+defm time_region
+    : mDashEq<"time-region", "time_region",
+              "Emit time statistics for specified region of linker operation ">,
+      MetaVarName<"<region>">,
+      Group<grp_diagopts>;
 
 def print_timing_stats
-    : Flag<["-", "--"], "print-timing-stats">,
+    : Flag<[ "-", "--" ], "print-timing-stats">,
       HelpText<"Print time statistics of various linker operatons to console">,
       Group<grp_diagopts>;
 defm gc_cref : mDashEq<"gc-cref", "gc_cref",
                        "Print the references for a symbol or section when "
                        "garbage collection is enabled">,
-              MetaVarName<"<symbol/section>">,
+               MetaVarName<"<symbol/section>">,
                Group<grp_diagopts>;
 def verbose : Flag<["--"], "verbose">,
               HelpText<"Enable verbose output">,
@@ -768,7 +776,7 @@ defm error_style
 defm color : smDash<"color", "color", "Enable color output for diagnostics">,
              MetaVarName<"<on/off>">,
              Group<grp_diagopts>;
-def opt_record_file : Flag<["-", "--"], "opt-record-file">,
+def opt_record_file : Flag<[ "-", "--" ], "opt-record-file">,
                       HelpText<"Create diagnostic yaml file">,
                       Group<grp_diagopts>;
 defm display_hotness
@@ -782,55 +790,63 @@ def summary : Flag<["--"], "summary">,
               HelpText<"Display linker run summary at the end">,
               Group<grp_diagopts>;
 def fatal_internal_errors : Flag<["--"], "fatal-internal-errors">,
-                     HelpText<"Enable fatal internal errors">,
-                     Group<grp_diagopts>;
+                            HelpText<"Enable fatal internal errors">,
+                            Group<grp_diagopts>;
 def no_fatal_internal_errors : Flag<["--"], "no-fatal-internal-errors">,
-                     HelpText<"Disable fatal internal errors">,
-                     Group<grp_diagopts>;
+                               HelpText<"Disable fatal internal errors">,
+                               Group<grp_diagopts>;
 defm error_limit
-    : mDashEq<"error-limit", "error_limit",
-              "Maximum number of errors to emit before stopping (0 = no limit)">,
+    : mDashEq<
+          "error-limit", "error_limit",
+          "Maximum number of errors to emit before stopping (0 = no limit)">,
       MetaVarName<"<max-error-number>">,
       Group<grp_diagopts>;
-defm warn_limit
-    : mDashEq<"warn-limit", "warn_limit",
-              "Maximum number of warnings to emit (0 = no limit)">,
-      MetaVarName<"<maxwarnings>">,
+defm warn_limit : mDashEq<"warn-limit", "warn_limit",
+                          "Maximum number of warnings to emit (0 = no limit)">,
+                  MetaVarName<"<maxwarnings>">,
+                  Group<grp_diagopts>;
+def W
+    : Joined<["-"], "W">,
+      MetaVarName<"<warn-type>">,
+      HelpText<"Print warnings which are OFF by default\n"
+               "\t\t\t -Wall : print all warnings\n"
+               "\t\t\t -W[no]linker-script : display warnings detected"
+               " while parsing linker scripts\n"
+               "\t\t\t -W[no]attribute-mix : display a warning if object files"
+               " of RISC-V with different attributes are being linked\n"
+               "\t\t\t -W[no-]archive-file : display warnings detected while "
+               "reading archive files\n"
+               "\t\t\t -W[no-]linker-script-memory : display warnings detected "
+               "while "
+               "processing linker script memory command\n"
+               "\t\t\t -W[no-]bad-dot-assignments : display warnings for bad "
+               "dot assignments\n"
+               "\t\t\t -W[no-]error : treat warnings as errors\n"
+               "\t\t\t -Wwhole-archive : display a warning when whole-archive "
+               "is enabled for any archive file\n"
+               "\t\t\t -W[no-]osabi : display a warning when linking objects "
+               "with different values for OS/ABI\n">,
       Group<grp_diagopts>;
-def W : Joined<["-"], "W">,
-        MetaVarName<"<warn-type>">,
-        HelpText<"Print warnings which are OFF by default\n"
-             "\t\t\t -Wall : print all warnings\n"
-             "\t\t\t -W[no]linker-script : display warnings detected"
-             " while parsing linker scripts\n"
-             "\t\t\t -W[no]attribute-mix : display a warning if object files"
-             " of RISC-V with different attributes are being linked\n"
-             "\t\t\t -W[no-]archive-file : display warnings detected while "
-             "reading archive files\n"
-             "\t\t\t -W[no-]linker-script-memory : display warnings detected while "
-             "processing linker script memory command\n"
-             "\t\t\t -W[no-]bad-dot-assignments : display warnings for bad "
-             "dot assignments\n"
-             "\t\t\t -W[no-]error : treat warnings as errors\n"
-             "\t\t\t -Wwhole-archive : display a warning when whole-archive "
-             "is enabled for any archive file\n"
-             "\t\t\t -W[no-]osabi : display a warning when linking objects "
-             "with different values for OS/ABI\n"
-            >,
-        Group<grp_diagopts>;
+def print_memory_report : Flag<["--"], "print-memory-report">,
+                          HelpText<"Print linker memory allocation report ">,
+                          Group<grp_diagopts>;
+defm emit_memory_report : mDashEq<"emit-memory-report", "emit_memory_report",
+                                  "Emit linker memory allocation report">,
+                          MetaVarName<"<filename>">,
+                          Group<grp_diagopts>;
 
 //===----------------------------------------------------------------------===//
 /// Optimization options
 //===----------------------------------------------------------------------===//
 def grp_optimizationopts : OptionGroup<"opts">,
                            HelpText<"OPTIMIZATION OPTIONS">;
-def gc_sections : Flag<["-", "--"], "gc-sections">,
+def gc_sections : Flag<[ "-", "--" ], "gc-sections">,
                   HelpText<"Enable garbage collection">,
                   Group<grp_optimizationopts>;
-def no_gc_sections : Flag<["-", "--"], "no-gc-sections">,
+def no_gc_sections : Flag<[ "-", "--" ], "no-gc-sections">,
                      HelpText<"Disable garbage collection">,
                      Group<grp_optimizationopts>;
-def print_gc_sections : Flag<["-", "--"], "print-gc-sections">,
+def print_gc_sections : Flag<[ "-", "--" ], "print-gc-sections">,
                         HelpText<"Print sections that are garbage collected">,
                         Group<grp_optimizationopts>;
 def eh_frame_hdr
@@ -849,13 +865,14 @@ def no_trampolines : Flag<["--"], "no-trampolines">,
 //===----------------------------------------------------------------------===//
 def grp_extendedopts : OptionGroup<"opts">, HelpText<"Extended Options">;
 defm dash_z
-    : dashEqWithJoinedOpt<
-          "z", "z", "dash_z",
-          "Extended Options or Non standard options.\n\t\t\t Available options are:\n"
-          "\t\t\t-z=combreloc : Combines multiple reloc sections and sorts them to make dynamic"
-          "symbol lookup caching\n"
-          "\t\t\t-z=now : Enables immediate binding\n"
-          "\t\t\t-z=nocopyreloc : Disables Copy Relocation">,
+    : dashEqWithJoinedOpt<"z", "z", "dash_z",
+                          "Extended Options or Non standard options.\n\t\t\t "
+                          "Available options are:\n"
+                          "\t\t\t-z=combreloc : Combines multiple reloc "
+                          "sections and sorts them to make dynamic"
+                          "symbol lookup caching\n"
+                          "\t\t\t-z=now : Enables immediate binding\n"
+                          "\t\t\t-z=nocopyreloc : Disables Copy Relocation">,
       MetaVarName<"<extended-opts>">,
       Group<grp_extendedopts>;
 def no_align_segments : Flag<["--"], "no-align-segments">,
@@ -883,7 +900,7 @@ def rosegment
 defm copy_farcalls_from_file
     : smDashWithOpt<"copy-farcalls-from-file", "copy_farcalls_from_file",
                     "Copy far calls instead of using trampolines">,
-                    MetaVarName<"<filename>">,
+      MetaVarName<"<filename>">,
       Group<grp_extendedopts>;
 defm no_reuse_trampolines_file
     : smDashWithOpt<"no-reuse-trampolines-file", "no_reuse_trampolines_file",
@@ -891,7 +908,7 @@ defm no_reuse_trampolines_file
       MetaVarName<"<filename>">,
       Group<grp_extendedopts>;
 def use_old_style_trampoline_name
-    : Flag<["--"],"use-old-style-trampoline-name">,
+    : Flag<["--"], "use-old-style-trampoline-name">,
       HelpText<"Use old style of naming trampolines">,
       Group<grp_extendedopts>;
 def no_emit_relocs : Flag<[ "-", "--" ], "no-emit-relocs">,
@@ -910,20 +927,22 @@ def allow_bss_conversion
 defm reproduce : smDash<"reproduce", "reproduce",
                         "Write a tar file containing input files and command "
                         "line options to inspect and re-link">,
-                  MetaVarName<"<tarfilename>">,
+                 MetaVarName<"<tarfilename>">,
                  Group<grp_extendedopts>;
-defm reproduce_compressed : smDashWithOpt<"reproduce-compressed", "reproduce_compressed",
-                                   "Write compressed tar file in zlib format "
-                                   "containing input files and command line "
-                                   "options to inspect and re-link.">,
-                            MetaVarName<"<tarfilename>">,
-                            Group<grp_extendedopts>;
-defm reproduce_on_fail : smDashWithOpt<"reproduce-on-fail", "reproduce_on_fail",
-                                   "Write reproduce tar file when link fails"
-                                   "containing input files and command line "
-                                   "options to inspect and re-link.">,
-                            MetaVarName<"<tarfilename>">,
-                            Group<grp_extendedopts>;
+defm reproduce_compressed
+    : smDashWithOpt<"reproduce-compressed", "reproduce_compressed",
+                    "Write compressed tar file in zlib format "
+                    "containing input files and command line "
+                    "options to inspect and re-link.">,
+      MetaVarName<"<tarfilename>">,
+      Group<grp_extendedopts>;
+defm reproduce_on_fail
+    : smDashWithOpt<"reproduce-on-fail", "reproduce_on_fail",
+                    "Write reproduce tar file when link fails"
+                    "containing input files and command line "
+                    "options to inspect and re-link.">,
+      MetaVarName<"<tarfilename>">,
+      Group<grp_extendedopts>;
 defm mapping_file : smDashWithOpt<"mapping-file", "mapping_file",
                                   "Reproduce link using a mapping file">,
                     MetaVarName<"<INI-file>">,
@@ -935,13 +954,11 @@ defm dump_mapping_file : smDashWithOpt<"dump-mapping-file", "dump_mapping_file",
 defm dump_response_file
     : smDashWithOpt<"dump-response-file", "dump_response_file",
                     "Dump response file to output file">,
-                    MetaVarName<"<outputfilename>">,
+      MetaVarName<"<outputfilename>">,
       Group<grp_extendedopts>;
-def about :
-     Flag<["--"], "about">,
-      HelpText<"Emit detailed information about the linker">,
-      Group<grp_extendedopts>;
-
+def about : Flag<["--"], "about">,
+            HelpText<"Emit detailed information about the linker">,
+            Group<grp_extendedopts>;
 
 //===----------------------------------------------------------------------===//
 /// Map file
@@ -1017,14 +1034,14 @@ def no_allow_shlib_undefs
       Group<grp_compatorignoredopts>;
 defm plugin_gnu
     : smDashWithOpt<"plugin", "plugin_gnu", "Specify a plugin file">,
-    MetaVarName<"<pluginfile>">,
+      MetaVarName<"<pluginfile>">,
       Group<grp_compatorignoredopts>;
 defm plugin_opt
     : smDashWithOpt<"plugin-opt", "plugin_opt", "Specify plugin options">,
       MetaVarName<"<plugin-opt>">,
       Group<grp_compatorignoredopts>;
 def thin_archive_rule_matching_compatibility
-    : Flag<["-", "--"], "thin-archive-rule-matching-compatibility">,
+    : Flag<[ "-", "--" ], "thin-archive-rule-matching-compatibility">,
       HelpText<"Provides rule-matching compatibility when fat archives are\n"
                "\t\t\tconverted to thin archives">,
       Group<grp_compatorignoredopts>;
@@ -1033,7 +1050,7 @@ def thin_archive_rule_matching_compatibility
 /// LTO options
 //===----------------------------------------------------------------------===//
 def grp_ltooptions : OptionGroup<"opts">, HelpText<"LTO Options">;
-def flto : Flag<["-", "--"], "flto">,
+def flto : Flag<[ "-", "--" ], "flto">,
            HelpText<"Enable LTO if a Bitcode file is present.">,
            Group<grp_ltooptions>;
 defm flto_options
@@ -1041,17 +1058,17 @@ defm flto_options
                     "Specify various options with LTO">,
       MetaVarName<"<option>">,
       Group<grp_ltooptions>;
-def flto_use_as : Flag<["-", "--"], "flto-use-as">,
+def flto_use_as : Flag<[ "-", "--" ], "flto-use-as">,
                   HelpText<"Use the standalone assembler instead of the "
                            "integrated assembler for LTO">,
                   Group<grp_ltooptions>;
-def save_temps : Flag<["-", "--"], "save-temps">,
+def save_temps : Flag<[ "-", "--" ], "save-temps">,
                  HelpText<"Save the temporary files produced by LTO">,
                  Group<grp_ltooptions>;
 defm save_temps_EQ : smDashOnlyEq<"save-temps", "save_temps_EQ",
-                 "Save the temporary files produced by LTO">,
-                 MetaVarName<"<filename>">,
-                 Group<grp_ltooptions>;
+                                  "Save the temporary files produced by LTO">,
+                     MetaVarName<"<filename>">,
+                     Group<grp_ltooptions>;
 defm exclude_lto_filelist
     : smDashWithOpt<"exclude-lto-filelist", "exclude_lto_filelist",
                     "Specify a list of files that are to be disregarded while "
@@ -1084,7 +1101,7 @@ defm plugin_opt_sample_profile
 /// Linker speedup and control
 //===----------------------------------------------------------------------===//
 def grp_linktime : OptionGroup<"opts">, HelpText<"Link Time Speedup">;
-def threads : Flag<["-", "--"], "threads">,
+def threads : Flag<[ "-", "--" ], "threads">,
               HelpText<"Enable Threads at Link time">,
               Group<grp_linktime>;
 defm enable_threads
@@ -1092,7 +1109,7 @@ defm enable_threads
                    "make linker fully threaded, available options: all">,
       MetaVarName<"<option>">,
       Group<grp_linktime>;
-def no_threads : Flag<["-", "--"], "no-threads">,
+def no_threads : Flag<[ "-", "--" ], "no-threads">,
                  HelpText<"Disable Threads at Link time">,
                  Group<grp_linktime>;
 defm thread_count
@@ -1106,19 +1123,18 @@ defm thread_count
 //===----------------------------------------------------------------------===//
 def grp_otherlinker : OptionGroup<"opts">,
                       HelpText<"Features From other Linkers">;
-def symdef : Flag<["-", "--"], "symdef">,
+def symdef : Flag<[ "-", "--" ], "symdef">,
              HelpText<"Output SymDef file to console">,
              Group<grp_otherlinker>;
 defm symdef_file : mDashEq<"symdef-file", "symdef_file", "Emit SymDef file">,
                    MetaVarName<"<filename>">,
                    Group<grp_otherlinker>;
-defm symdef_style
-    : mDashEq<
-          "symdef-style", "symdef_style",
-          "Determine how to handle symbol resolution for symbols from symdef file, Options available are "
-          "provide">,
-      MetaVarName<"<style>">,
-      Group<grp_otherlinker>;
+defm symdef_style : mDashEq<"symdef-style", "symdef_style",
+                            "Determine how to handle symbol resolution for "
+                            "symbols from symdef file, Options available are "
+                            "provide">,
+                    MetaVarName<"<style>">,
+                    Group<grp_otherlinker>;
 defm R : smDash<"R", "just-symbols",
                 "Read symbol names and addresses from filename">,
          MetaVarName<"<filename>">,
@@ -1132,17 +1148,16 @@ defm plugin_config : mDashEq<"plugin-config", "plugin_config",
                              "Specify a plugin configuration">,
                      MetaVarName<"<config-file>">,
                      Group<grp_pluginopts>;
-def noDefaultPlugins
-    : Flag<["--"], "no-default-plugins">,
-      HelpText<"Allow no plugins to be implicitly loaded">,
-      Group<grp_pluginopts>;
+def noDefaultPlugins : Flag<["--"], "no-default-plugins">,
+                       HelpText<"Allow no plugins to be implicitly loaded">,
+                       Group<grp_pluginopts>;
 
 //===----------------------------------------------------------------------===//
 /// Other Features
 //===----------------------------------------------------------------------===//
 def grp_miscfeatures : OptionGroup<"otherfeatures">, HelpText<"Misc Features">;
 def allow_incompatible_section_mix
-    : Flag<["-", "--"], "allow-incompatible-section-mix">,
+    : Flag<[ "-", "--" ], "allow-incompatible-section-mix">,
       HelpText<"Allow incompatible section mix">,
       Group<grp_miscfeatures>;
 
@@ -1150,10 +1165,10 @@ def allow_incompatible_section_mix
 /// Help!
 //===----------------------------------------------------------------------===//
 def grp_help : OptionGroup<"opts">, HelpText<"Help!">;
-def help : Flag<["--", "-"], "help">,
+def help : Flag<[ "--", "-" ], "help">,
            HelpText<"Print option help">,
            Group<grp_help>;
-def help_hidden : Flag<["--", "-"], "help-hidden">,
+def help_hidden : Flag<[ "--", "-" ], "help-hidden">,
                   HelpText<"Print hidden option help">,
                   Group<grp_help>;
 
@@ -1161,8 +1176,10 @@ def help_hidden : Flag<["--", "-"], "help-hidden">,
 /// Input formats!
 //===----------------------------------------------------------------------===//
 def grp_input_formats : OptionGroup<"opts">, HelpText<"Input Format">;
-defm input_format : smDashTwoWithOpt<"b", "format", "input_format",
-                      "Specify input format for inputs following this option.\n"
-                      "Supported values: binary,default">,
-                    MetaVarName<"<input-format>">,
-                    Group<grp_input_formats>;
+defm input_format
+    : smDashTwoWithOpt<
+          "b", "format", "input_format",
+          "Specify input format for inputs following this option.\n"
+          "Supported values: binary,default">,
+      MetaVarName<"<input-format>">,
+      Group<grp_input_formats>;
diff --git a/include/eld/Driver/HexagonLinkDriver.h b/include/eld/Driver/HexagonLinkDriver.h
index f9beb094e..0cc3d18e1 100644
--- a/include/eld/Driver/HexagonLinkDriver.h
+++ b/include/eld/Driver/HexagonLinkDriver.h
@@ -15,6 +15,9 @@
 
 // Create OptTable class for parsing actual command line arguments
 class OPT_HexagonLinkOptTable : public llvm::opt::GenericOptTable {
+public:
+  static std::string getTypeName() { return "OPT_HexagonLinkOptTable"; }
+
 public:
   // Create enum with OPT_xxx values for each option in DarwinLdOptions.td
   enum {
@@ -31,6 +34,9 @@ class OPT_HexagonLinkOptTable : public llvm::opt::GenericOptTable {
 };
 
 class HexagonLinkDriver : public GnuLdDriver {
+public:
+  static std::string getTypeName() { return "HexagonLinkDriver"; }
+
 public:
   static HexagonLinkDriver *Create(eld::LinkerConfig &C,
                                    std::string InferredArchFromProgramName);
diff --git a/include/eld/Driver/RISCVLinkDriver.h b/include/eld/Driver/RISCVLinkDriver.h
index 7807df687..7a20471e7 100644
--- a/include/eld/Driver/RISCVLinkDriver.h
+++ b/include/eld/Driver/RISCVLinkDriver.h
@@ -15,6 +15,9 @@
 
 // Create OptTable class for parsing actual command line arguments
 class OPT_RISCVLinkOptTable : public llvm::opt::GenericOptTable {
+public:
+  static std::string getTypeName() { return "OPT_RISCVLinkOptTable"; }
+
 public:
   enum {
     INVALID = 0,
@@ -30,6 +33,9 @@ class OPT_RISCVLinkOptTable : public llvm::opt::GenericOptTable {
 };
 
 class RISCVLinkDriver : public GnuLdDriver {
+public:
+  static std::string getTypeName() { return "RISCVLinkDriver"; }
+
 public:
   static RISCVLinkDriver *Create(eld::LinkerConfig &C,
                                  std::string InferredArchFromProgramName);
diff --git a/include/eld/Driver/x86_64LinkDriver.h b/include/eld/Driver/x86_64LinkDriver.h
index 2bcda58cd..00b232a14 100644
--- a/include/eld/Driver/x86_64LinkDriver.h
+++ b/include/eld/Driver/x86_64LinkDriver.h
@@ -17,6 +17,9 @@
 
 // Create OptTable class for parsing actual command line arguments
 class OPT_x86_64LinkOptTable : public llvm::opt::GenericOptTable {
+public:
+  static std::string getTypeName() { return "OPT_x86_64LinkOptTable"; }
+
 public:
   enum {
     INVALID = 0,
@@ -32,6 +35,9 @@ class OPT_x86_64LinkOptTable : public llvm::opt::GenericOptTable {
 };
 
 class x86_64LinkDriver : public GnuLdDriver {
+public:
+  static std::string getTypeName() { return "x86_64LinkDriver"; }
+
 public:
   static x86_64LinkDriver *Create(eld::LinkerConfig &C,
                                   std::string InferredArchFromProgramName);
diff --git a/include/eld/Fragment/BuildIDFragment.h b/include/eld/Fragment/BuildIDFragment.h
index 63e519848..7f4dca386 100644
--- a/include/eld/Fragment/BuildIDFragment.h
+++ b/include/eld/Fragment/BuildIDFragment.h
@@ -18,6 +18,10 @@ class LinkerConfig;
  *  of the program, that can be used to uniquely identify this program
  */
 class BuildIDFragment : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "BuildIDFragment"; }
+
 public:
   enum BuildIDKind : uint8_t { NONE, FAST, MD5, UUID, SHA1, HEXSTRING };
 
diff --git a/include/eld/Fragment/EhFrameFragment.h b/include/eld/Fragment/EhFrameFragment.h
index 20870559d..acca8db09 100644
--- a/include/eld/Fragment/EhFrameFragment.h
+++ b/include/eld/Fragment/EhFrameFragment.h
@@ -21,6 +21,10 @@ class LinkerConfig;
 class Relocation;
 
 class EhFramePiece {
+public:
+public:
+  static std::string getTypeName() { return "EhFramePiece"; }
+
 public:
   EhFramePiece(size_t Off, size_t Sz, Relocation *R, EhFrameSection *O)
       : MOffset(Off), ThisSize(Sz), MRelocation(R), MSection(O) {}
@@ -65,6 +69,10 @@ class EhFramePiece {
 };
 
 class FDEFragment : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "FDEFragment"; }
+
 public:
   FDEFragment(EhFramePiece &P, EhFrameSection *O);
 
@@ -96,6 +104,10 @@ class FDEFragment : public Fragment {
 };
 
 class CIEFragment : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "CIEFragment"; }
+
 public:
   CIEFragment(EhFramePiece &P, EhFrameSection *O);
 
diff --git a/include/eld/Fragment/EhFrameHdrFragment.h b/include/eld/Fragment/EhFrameHdrFragment.h
index fede96190..6cc1894e0 100644
--- a/include/eld/Fragment/EhFrameHdrFragment.h
+++ b/include/eld/Fragment/EhFrameHdrFragment.h
@@ -24,8 +24,15 @@ class FDEFragment;
 class Relocation;
 
 class EhFrameHdrFragment : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "EhFrameHdrFragment"; }
+
 public:
   struct FdeData {
+  public:
+  public:
+    static std::string getTypeName() { return "FdeData"; }
     uint32_t PcRel;
     uint32_t FdeVARel;
   };
diff --git a/include/eld/Fragment/FillFragment.h b/include/eld/Fragment/FillFragment.h
index 086705691..e323d8439 100644
--- a/include/eld/Fragment/FillFragment.h
+++ b/include/eld/Fragment/FillFragment.h
@@ -21,6 +21,10 @@ class ELFSection;
 class LinkerConfig;
 
 class FillFragment : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "FillFragment"; }
+
 public:
   FillFragment(Module &M, uint64_t PValue, size_t PSize,
                ELFSection *O = nullptr, size_t PAlignment = 1);
diff --git a/include/eld/Fragment/Fragment.h b/include/eld/Fragment/Fragment.h
index 54f57aa6a..366f695fa 100644
--- a/include/eld/Fragment/Fragment.h
+++ b/include/eld/Fragment/Fragment.h
@@ -30,6 +30,10 @@ class ResolveInfo;
  *  \brief Fragment is the minimun linking unit of MCLinker.
  */
 class Fragment {
+public:
+public:
+  static std::string getTypeName() { return "Fragment"; }
+
 public:
   /* Null means this fragment is removed */
   enum Type : uint8_t {
diff --git a/include/eld/Fragment/FragmentRef.h b/include/eld/Fragment/FragmentRef.h
index dc809cbed..6580604ce 100644
--- a/include/eld/Fragment/FragmentRef.h
+++ b/include/eld/Fragment/FragmentRef.h
@@ -16,6 +16,7 @@
 
 #include "eld/Config/Config.h"
 #include "llvm/Support/DataTypes.h"
+#include <string>
 
 namespace eld {
 
@@ -31,6 +32,10 @@ class OutputSectionEntry;
  *
  */
 class FragmentRef {
+public:
+public:
+  static std::string getTypeName() { return "FragmentRef"; }
+
 public:
   typedef uint64_t Offset; // FIXME: use SizeTraits<T>::Offset
 
diff --git a/include/eld/Fragment/GNUHashFragment.h b/include/eld/Fragment/GNUHashFragment.h
index 5dbbd3a4b..c9079b916 100644
--- a/include/eld/Fragment/GNUHashFragment.h
+++ b/include/eld/Fragment/GNUHashFragment.h
@@ -63,6 +63,9 @@ template <class ELFT> class GNUHashFragment : public TargetFragment {
 
 private:
   struct SymbolData {
+  public:
+  public:
+    static std::string getTypeName() { return "SymbolData"; }
     ResolveInfo *R;
     uint32_t DynSymIndex;
     uint32_t Hash;
diff --git a/include/eld/Fragment/GOT.h b/include/eld/Fragment/GOT.h
index 618218c53..aa5affca3 100644
--- a/include/eld/Fragment/GOT.h
+++ b/include/eld/Fragment/GOT.h
@@ -19,6 +19,10 @@ class LinkerConfig;
 class ResolveInfo;
 
 class GOT : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "GOT"; }
+
 public:
   // GOT Types.
   enum GOTType {
diff --git a/include/eld/Fragment/MergeStringFragment.h b/include/eld/Fragment/MergeStringFragment.h
index 6957dbca4..6e820ad86 100644
--- a/include/eld/Fragment/MergeStringFragment.h
+++ b/include/eld/Fragment/MergeStringFragment.h
@@ -26,6 +26,9 @@ class OutputSectionEntry;
 /// this string and the input offset of the next string. Fragment Pointer could
 /// also be removed.
 struct MergeableString {
+public:
+public:
+  static std::string getTypeName() { return "MergeableString"; }
   MergeStringFragment *Fragment;
   llvm::StringRef String;
   uint32_t InputOffset;
@@ -45,6 +48,9 @@ struct MergeableString {
 /// MergeStringFrgament is a Fragment that manages MergeableStrings of a
 /// LDFileFormat::MergeStr input section.
 class MergeStringFragment : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "MergeStringFragment"; }
   std::vector<MergeableString *> Strings;
 
 public:
diff --git a/include/eld/Fragment/OutputSectDataFragment.h b/include/eld/Fragment/OutputSectDataFragment.h
index 51a7c77a0..7acf0b103 100644
--- a/include/eld/Fragment/OutputSectDataFragment.h
+++ b/include/eld/Fragment/OutputSectDataFragment.h
@@ -12,6 +12,10 @@
 
 namespace eld {
 class OutputSectDataFragment : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "OutputSectDataFragment"; }
+
 public:
   OutputSectDataFragment(OutputSectData &OutSectData);
 
diff --git a/include/eld/Fragment/PLT.h b/include/eld/Fragment/PLT.h
index f98674720..6c91f6b0a 100644
--- a/include/eld/Fragment/PLT.h
+++ b/include/eld/Fragment/PLT.h
@@ -21,6 +21,10 @@ class ResolveInfo;
 class GOT;
 
 class PLT : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "PLT"; }
+
 public:
   // PLT Types.
   enum PLTType {
diff --git a/include/eld/Fragment/RegionFragment.h b/include/eld/Fragment/RegionFragment.h
index 9ef516447..a5087d35c 100644
--- a/include/eld/Fragment/RegionFragment.h
+++ b/include/eld/Fragment/RegionFragment.h
@@ -25,6 +25,11 @@ class LinkerConfig;
  */
 // Region fragment expression
 class RegionFragment : public Fragment {
+public:
+public:
+public:
+  static std::string getTypeName() { return "RegionFragment"; }
+
 public:
   RegionFragment(llvm::StringRef PRegion, ELFSection *O, Fragment::Type T,
                  uint32_t Align = 1);
diff --git a/include/eld/Fragment/RegionFragmentEx.h b/include/eld/Fragment/RegionFragmentEx.h
index fc865a12b..949663fba 100644
--- a/include/eld/Fragment/RegionFragmentEx.h
+++ b/include/eld/Fragment/RegionFragmentEx.h
@@ -19,6 +19,10 @@ class LinkerConfig;
  *         that has capability of deleting, inserting, replacing and aligning.
  */
 class RegionFragmentEx : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "RegionFragmentEx"; }
+
 public:
   RegionFragmentEx(const char *Data, size_t Sz, ELFSection *O = nullptr,
                    uint32_t Align = 1);
diff --git a/include/eld/Fragment/StringFragment.h b/include/eld/Fragment/StringFragment.h
index fad27f8fc..ba170121c 100644
--- a/include/eld/Fragment/StringFragment.h
+++ b/include/eld/Fragment/StringFragment.h
@@ -17,6 +17,10 @@ class LinkerConfig;
  *  the strings are terminated with \0.
  */
 class StringFragment : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "StringFragment"; }
+
 public:
   StringFragment(std::string Str, ELFSection *O = nullptr);
 
diff --git a/include/eld/Fragment/Stub.h b/include/eld/Fragment/Stub.h
index d0cddc354..085658564 100644
--- a/include/eld/Fragment/Stub.h
+++ b/include/eld/Fragment/Stub.h
@@ -30,11 +30,19 @@ class Relocation;
 class ResolveInfo;
 
 class Stub : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "Stub"; }
+
 public:
   typedef Relocation::DWord DWord;
   typedef Relocation::SWord SWord;
   typedef Relocation::Type Type;
   class Fixup {
+  public:
+  public:
+    static std::string getTypeName() { return "Fixup"; }
+
   public:
     Fixup(DWord POffset, SWord PAddend, Type PType)
         : MOffset(POffset), MAddend(PAddend), MType(PType) {}
diff --git a/include/eld/Fragment/TargetFragment.h b/include/eld/Fragment/TargetFragment.h
index ec865f603..301506f6e 100644
--- a/include/eld/Fragment/TargetFragment.h
+++ b/include/eld/Fragment/TargetFragment.h
@@ -24,6 +24,10 @@ class ResolveInfo;
 class GNULDBackend;
 
 class TargetFragment : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "TargetFragment"; }
+
 public:
   enum Kind : uint8_t {
     Attributes,
diff --git a/include/eld/Fragment/TimingFragment.h b/include/eld/Fragment/TimingFragment.h
index de60bd56d..3886c862a 100644
--- a/include/eld/Fragment/TimingFragment.h
+++ b/include/eld/Fragment/TimingFragment.h
@@ -13,6 +13,10 @@ namespace eld {
 class LinkerConfig;
 
 class TimingFragment : public Fragment {
+public:
+public:
+  static std::string getTypeName() { return "TimingFragment"; }
+
 public:
   TimingFragment(uint64_t BeginningOfTime, uint64_t Duration,
                  llvm::StringRef ModuleName, ELFSection *O);
diff --git a/include/eld/GarbageCollection/GarbageCollection.h b/include/eld/GarbageCollection/GarbageCollection.h
index 208815c0c..29d477459 100644
--- a/include/eld/GarbageCollection/GarbageCollection.h
+++ b/include/eld/GarbageCollection/GarbageCollection.h
@@ -32,6 +32,9 @@ class GNULDBackend;
  *  @ref GNU gold, gc.
  */
 class GarbageCollection {
+public:
+  static std::string getTypeName() { return "GarbageCollection"; }
+
 public:
   typedef llvm::DenseSet<Section *> SectionListTy;
   typedef llvm::DenseSet<LDSymbol *> SymbolListTy;
@@ -41,6 +44,9 @@ class GarbageCollection {
    *  \brief Map the section to the list of sections which it can reach directly
    */
   class SectionReachedListMap {
+  public:
+    static std::string getTypeName() { return "SectionReachedListMap"; }
+
   public:
     SectionReachedListMap() {}
 
diff --git a/include/eld/Input/ArchiveFile.h b/include/eld/Input/ArchiveFile.h
index e7bf524a7..cc606b4fd 100644
--- a/include/eld/Input/ArchiveFile.h
+++ b/include/eld/Input/ArchiveFile.h
@@ -24,9 +24,14 @@ namespace eld {
 struct ArchiveFileInfo;
 class DiagnosticPrinter;
 class ArchiveFile : public InputFile {
+public:
+  static std::string getTypeName() { return "ArchiveFile"; }
+
 public:
   // -----------Declare Types ----------------
   struct Symbol {
+  public:
+    static std::string getTypeName() { return "Symbol"; }
     enum SymbolStatus { Include, Exclude, Unknown };
 
     enum SymbolType { NoType, DefineData, DefineFunction, Common, Weak };
diff --git a/include/eld/Input/ArchiveFileInfo.h b/include/eld/Input/ArchiveFileInfo.h
index 6a2d8acbe..7eae06fe4 100644
--- a/include/eld/Input/ArchiveFileInfo.h
+++ b/include/eld/Input/ArchiveFileInfo.h
@@ -15,6 +15,8 @@ namespace eld {
 // when an archive file is read multiple times. For instance, if an archive file
 // is repeated in the link command, then it is read multiple times.
 struct ArchiveFileInfo {
+public:
+  static std::string getTypeName() { return "ArchiveFileInfo"; }
   ArchiveFileInfo() = default;
   ~ArchiveFileInfo() = default;
   llvm::DenseMap<off_t, Input *> LazyLoadMemberMap;
diff --git a/include/eld/Input/ArchiveMemberInput.h b/include/eld/Input/ArchiveMemberInput.h
index 7ee3c1268..73a4c38fd 100644
--- a/include/eld/Input/ArchiveMemberInput.h
+++ b/include/eld/Input/ArchiveMemberInput.h
@@ -19,6 +19,9 @@ class DiagnosticEngine;
 class DiagnosticPrinter;
 
 class ArchiveMemberInput : public Input {
+public:
+  static std::string getTypeName() { return "ArchiveMemberInput"; }
+
 public:
   explicit ArchiveMemberInput(DiagnosticEngine *DiagEngine,
                               ArchiveFile *ArchiveFile, llvm::StringRef Name,
diff --git a/include/eld/Input/BinaryFile.h b/include/eld/Input/BinaryFile.h
index d0d8e5e21..6147c36b9 100644
--- a/include/eld/Input/BinaryFile.h
+++ b/include/eld/Input/BinaryFile.h
@@ -17,6 +17,9 @@ namespace eld {
 /// binary format input file as a block of data that is put verbatim into the
 /// output file.
 class BinaryFile : public ObjectFile {
+public:
+  static std::string getTypeName() { return "BinaryFile"; }
+
 public:
   BinaryFile(Input *I, DiagnosticEngine *DiagEngine);
 
diff --git a/include/eld/Input/BitcodeFile.h b/include/eld/Input/BitcodeFile.h
index 088b92218..b878892cd 100644
--- a/include/eld/Input/BitcodeFile.h
+++ b/include/eld/Input/BitcodeFile.h
@@ -37,6 +37,9 @@ class DiagnosticEngine;
  *  that the rest of the linker can work with.
  */
 class BitcodeFile : public ObjectFile {
+public:
+  static std::string getTypeName() { return "BitcodeFile"; }
+
 public:
   BitcodeFile(Input *I, DiagnosticEngine *DiagEngine);
 
diff --git a/include/eld/Input/ELDDirectory.h b/include/eld/Input/ELDDirectory.h
index f73f95d10..3ecc180c7 100644
--- a/include/eld/Input/ELDDirectory.h
+++ b/include/eld/Input/ELDDirectory.h
@@ -24,6 +24,9 @@ namespace eld {
  *
  */
 class ELDDirectory {
+public:
+  static std::string getTypeName() { return "ELDDirectory"; }
+
 public:
   explicit ELDDirectory(llvm::StringRef PName, std::string SysRoot);
   virtual ~ELDDirectory();
diff --git a/include/eld/Input/ELFDynObjectFile.h b/include/eld/Input/ELFDynObjectFile.h
index 62da60aa6..c77411959 100644
--- a/include/eld/Input/ELFDynObjectFile.h
+++ b/include/eld/Input/ELFDynObjectFile.h
@@ -15,6 +15,9 @@ namespace eld {
  *  \brief InputFile represents a dynamic shared library.
  */
 class ELFDynObjectFile : public ELFFileBase {
+public:
+  static std::string getTypeName() { return "ELFDynObjectFile"; }
+
 public:
   ELFDynObjectFile(Input *I, DiagnosticEngine *DiagEngine);
 
diff --git a/include/eld/Input/ELFExecutableFile.h b/include/eld/Input/ELFExecutableFile.h
index fd01c5ab7..783e8f8c3 100644
--- a/include/eld/Input/ELFExecutableFile.h
+++ b/include/eld/Input/ELFExecutableFile.h
@@ -16,6 +16,9 @@ namespace eld {
  *  that the rest of the linker can work with.
  */
 class ELFExecutableFile : public ELFFileBase {
+public:
+  static std::string getTypeName() { return "ELFExecutableFile"; }
+
 public:
   ELFExecutableFile(Input *I, DiagnosticEngine *DiagEngine);
 
diff --git a/include/eld/Input/ELFFileBase.h b/include/eld/Input/ELFFileBase.h
index efb03732c..6bb0b93ec 100644
--- a/include/eld/Input/ELFFileBase.h
+++ b/include/eld/Input/ELFFileBase.h
@@ -20,6 +20,9 @@ class DiagnosticPrinter;
  *  that the rest of the linker can work with.
  */
 class ELFFileBase : public ObjectFile {
+public:
+  static std::string getTypeName() { return "ELFFileBase"; }
+
 public:
   ELFFileBase(Input *I, DiagnosticEngine *DiagEngine,
               InputFile::InputFileKind K)
diff --git a/include/eld/Input/ELFObjectFile.h b/include/eld/Input/ELFObjectFile.h
index dbf6e6a9c..393fc5c5e 100644
--- a/include/eld/Input/ELFObjectFile.h
+++ b/include/eld/Input/ELFObjectFile.h
@@ -21,6 +21,9 @@ class RelocMap;
  *  that the rest of the linker can work with.
  */
 class ELFObjectFile : public ELFFileBase {
+public:
+  static std::string getTypeName() { return "ELFObjectFile"; }
+
 public:
   ELFObjectFile(Input *I, DiagnosticEngine *DiagEngine);
 
diff --git a/include/eld/Input/Input.h b/include/eld/Input/Input.h
index a6a81ed5e..559f0b23a 100644
--- a/include/eld/Input/Input.h
+++ b/include/eld/Input/Input.h
@@ -40,6 +40,9 @@ class DiagnosticPrinter;
  *  \brief Input provides the information of a input file.
  */
 class Input {
+public:
+  static std::string getTypeName() { return "Input"; }
+
 public:
   enum InputType {
     Archive,       // This is used mainly by -Bstatic
diff --git a/include/eld/Input/InputAction.h b/include/eld/Input/InputAction.h
index 417758d71..57a7d4704 100644
--- a/include/eld/Input/InputAction.h
+++ b/include/eld/Input/InputAction.h
@@ -29,6 +29,9 @@ class Input;
  *  \brief InputAction is a command object to construct eld::InputTree.
  */
 class InputAction {
+public:
+  static std::string getTypeName() { return "InputAction"; }
+
 public:
   enum InputActionKind {
     AddNeeded,
@@ -77,6 +80,9 @@ class InputAction {
 
 /// InputFileAction
 class InputFileAction : public InputAction {
+public:
+  static std::string getTypeName() { return "InputFileAction"; }
+
 public:
   explicit InputFileAction(std::string Name, DiagnosticPrinter *Printer);
 
@@ -107,6 +113,9 @@ class InputFileAction : public InputAction {
 
 /// NamespecAction
 class NamespecAction : public InputAction {
+public:
+  static std::string getTypeName() { return "NamespecAction"; }
+
 public:
   NamespecAction(const std::string &PNamespec, DiagnosticPrinter *Printer);
 
@@ -129,6 +138,9 @@ class NamespecAction : public InputAction {
 
 /// StartGroupAction
 class StartGroupAction : public InputAction {
+public:
+  static std::string getTypeName() { return "StartGroupAction"; }
+
 public:
   explicit StartGroupAction(DiagnosticPrinter *Printer);
 
@@ -143,6 +155,9 @@ class StartGroupAction : public InputAction {
 
 /// EndGroupAction
 class EndGroupAction : public InputAction {
+public:
+  static std::string getTypeName() { return "EndGroupAction"; }
+
 public:
   explicit EndGroupAction(DiagnosticPrinter *Printer);
 
@@ -157,6 +172,9 @@ class EndGroupAction : public InputAction {
 
 /// WholeArchiveAction
 class WholeArchiveAction : public InputAction {
+public:
+  static std::string getTypeName() { return "WholeArchiveAction"; }
+
 public:
   explicit WholeArchiveAction(DiagnosticPrinter *Printer);
 
@@ -171,6 +189,9 @@ class WholeArchiveAction : public InputAction {
 
 /// NoWholeArchiveAction
 class NoWholeArchiveAction : public InputAction {
+public:
+  static std::string getTypeName() { return "NoWholeArchiveAction"; }
+
 public:
   explicit NoWholeArchiveAction(DiagnosticPrinter *Printer);
 
@@ -185,6 +206,9 @@ class NoWholeArchiveAction : public InputAction {
 
 /// AsNeededAction
 class AsNeededAction : public InputAction {
+public:
+  static std::string getTypeName() { return "AsNeededAction"; }
+
 public:
   explicit AsNeededAction(DiagnosticPrinter *Printer);
 
@@ -199,6 +223,9 @@ class AsNeededAction : public InputAction {
 
 /// PushStateAction
 class PushStateAction : public InputAction {
+public:
+  static std::string getTypeName() { return "PushStateAction"; }
+
 public:
   explicit PushStateAction(DiagnosticPrinter *Printer);
 
@@ -213,6 +240,9 @@ class PushStateAction : public InputAction {
 
 /// PopStateAction
 class PopStateAction : public InputAction {
+public:
+  static std::string getTypeName() { return "PopStateAction"; }
+
 public:
   explicit PopStateAction(DiagnosticPrinter *Printer);
 
@@ -227,6 +257,9 @@ class PopStateAction : public InputAction {
 
 /// NoAsNeededAction
 class NoAsNeededAction : public InputAction {
+public:
+  static std::string getTypeName() { return "NoAsNeededAction"; }
+
 public:
   explicit NoAsNeededAction(DiagnosticPrinter *Printer);
 
@@ -241,6 +274,9 @@ class NoAsNeededAction : public InputAction {
 
 /// AddNeededAction
 class AddNeededAction : public InputAction {
+public:
+  static std::string getTypeName() { return "AddNeededAction"; }
+
 public:
   explicit AddNeededAction(DiagnosticPrinter *Printer);
 
@@ -255,6 +291,9 @@ class AddNeededAction : public InputAction {
 
 /// NoAddNeededAction
 class NoAddNeededAction : public InputAction {
+public:
+  static std::string getTypeName() { return "NoAddNeededAction"; }
+
 public:
   explicit NoAddNeededAction(DiagnosticPrinter *Printer);
 
@@ -269,6 +308,9 @@ class NoAddNeededAction : public InputAction {
 
 /// BDynamicAction
 class BDynamicAction : public InputAction {
+public:
+  static std::string getTypeName() { return "BDynamicAction"; }
+
 public:
   explicit BDynamicAction(DiagnosticPrinter *Printer);
 
@@ -283,6 +325,9 @@ class BDynamicAction : public InputAction {
 
 /// BStaticAction
 class BStaticAction : public InputAction {
+public:
+  static std::string getTypeName() { return "BStaticAction"; }
+
 public:
   explicit BStaticAction(DiagnosticPrinter *Printer);
 
@@ -297,6 +342,9 @@ class BStaticAction : public InputAction {
 
 /// DefSymAction
 class DefSymAction : public InputAction {
+public:
+  static std::string getTypeName() { return "DefSymAction"; }
+
 public:
   explicit DefSymAction(std::string PAssignment, DiagnosticPrinter *Printer);
 
@@ -317,6 +365,9 @@ class DefSymAction : public InputAction {
 /// InputFormatAction handles the processing of '--format|-b <input_format>'
 /// command-line options.
 class InputFormatAction : public InputAction {
+public:
+  static std::string getTypeName() { return "InputFormatAction"; }
+
 public:
   explicit InputFormatAction(const std::string &InputFormat,
                              DiagnosticPrinter *Printer);
diff --git a/include/eld/Input/InputBuilder.h b/include/eld/Input/InputBuilder.h
index 5de65b3d4..4ee479a76 100644
--- a/include/eld/Input/InputBuilder.h
+++ b/include/eld/Input/InputBuilder.h
@@ -34,6 +34,9 @@ class DiagnosticEngine;
  *  InputBuilder build input tree and inputs.
  */
 class InputBuilder {
+public:
+  static std::string getTypeName() { return "InputBuilder"; }
+
 private:
   InputBuilder() = delete;
 
diff --git a/include/eld/Input/InputFile.h b/include/eld/Input/InputFile.h
index 4f7594119..4b084dc4e 100644
--- a/include/eld/Input/InputFile.h
+++ b/include/eld/Input/InputFile.h
@@ -22,6 +22,9 @@ class Input;
  *  that the rest of the linker can work with.
  */
 class InputFile {
+public:
+  static std::string getTypeName() { return "InputFile"; }
+
 public:
   enum InputFileKind {
     ELFObjFileKind,
diff --git a/include/eld/Input/InputTree.h b/include/eld/Input/InputTree.h
index 310ff2b1b..711088b7f 100644
--- a/include/eld/Input/InputTree.h
+++ b/include/eld/Input/InputTree.h
@@ -13,11 +13,16 @@
 #ifndef ELD_INPUT_INPUTTREE_H
 #define ELD_INPUT_INPUTTREE_H
 
+#include <string>
+
 namespace eld {
 
 class Input;
 
 class Node {
+public:
+  static std::string getTypeName() { return "Node"; }
+
 public:
   enum Kind { File, GroupStart, GroupEnd };
 
@@ -30,6 +35,9 @@ class Node {
 };
 
 class Attribute {
+public:
+  static std::string getTypeName() { return "Attribute"; }
+
 public:
   // -----  modifiers  ----- //
   void setWholeArchive() { WholeArchive = true; }
@@ -105,6 +113,9 @@ inline bool operator!=(const Attribute &PLhs, const Attribute &PRhs) {
 }
 
 class FileNode : public Node {
+public:
+  static std::string getTypeName() { return "FileNode"; }
+
 public:
   FileNode(Input *I) : Node(Node::File), In(I) {}
 
@@ -117,6 +128,9 @@ class FileNode : public Node {
 };
 
 class GroupStart : public Node {
+public:
+  static std::string getTypeName() { return "GroupStart"; }
+
 public:
   GroupStart() : Node(Node::GroupStart) {}
 
@@ -124,6 +138,9 @@ class GroupStart : public Node {
 };
 
 class GroupEnd : public Node {
+public:
+  static std::string getTypeName() { return "GroupEnd"; }
+
 public:
   GroupEnd() : Node(Node::GroupEnd) {}
 
diff --git a/include/eld/Input/InternalInputFile.h b/include/eld/Input/InternalInputFile.h
index f8a91f072..7f970d4a6 100644
--- a/include/eld/Input/InternalInputFile.h
+++ b/include/eld/Input/InternalInputFile.h
@@ -11,6 +11,9 @@
 namespace eld {
 
 class InternalInputFile : public ObjectFile {
+public:
+  static std::string getTypeName() { return "InternalInputFile"; }
+
 public:
   InternalInputFile(Input *I, DiagnosticEngine *diagEngine)
       : ObjectFile(I, InputFile::InternalInputKind, diagEngine) {
diff --git a/include/eld/Input/JustSymbolsAction.h b/include/eld/Input/JustSymbolsAction.h
index b1953b114..6a293bcce 100644
--- a/include/eld/Input/JustSymbolsAction.h
+++ b/include/eld/Input/JustSymbolsAction.h
@@ -15,6 +15,9 @@ class LinkerConfig;
 
 /// JustSymbolsAction
 class JustSymbolsAction : public InputFileAction {
+public:
+  static std::string getTypeName() { return "JustSymbolsAction"; }
+
 public:
   JustSymbolsAction(const std::string &FileName, const LinkerConfig &Config,
                     DiagnosticPrinter *DiagPrinter);
diff --git a/include/eld/Input/LinkerScriptFile.h b/include/eld/Input/LinkerScriptFile.h
index 425113415..0cbb80387 100644
--- a/include/eld/Input/LinkerScriptFile.h
+++ b/include/eld/Input/LinkerScriptFile.h
@@ -23,6 +23,9 @@ class Node;
 class ScriptFile;
 
 class LinkerScriptFile : public InputFile {
+public:
+  static std::string getTypeName() { return "LinkerScriptFile"; }
+
 public:
   LinkerScriptFile(Input *I, DiagnosticEngine *DiagEngine);
 
diff --git a/include/eld/Input/ObjectFile.h b/include/eld/Input/ObjectFile.h
index 957aada99..a5b61c93a 100644
--- a/include/eld/Input/ObjectFile.h
+++ b/include/eld/Input/ObjectFile.h
@@ -18,6 +18,8 @@ namespace eld {
 // A hash function used to hash a pair.
 // Used to hash elfsection and addend to indentify local symbols uniquely
 struct HashPair {
+public:
+  static std::string getTypeName() { return "HashPair"; }
   template <class T1, class T2>
   size_t operator()(const std::pair<T1, T2> &P) const {
     return llvm::hash_combine(P.first, P.second);
@@ -35,6 +37,9 @@ class DiagnosticPrinter;
  *  that the rest of the linker can work with.
  */
 class ObjectFile : public InputFile {
+public:
+  static std::string getTypeName() { return "ObjectFile"; }
+
 public:
   /// Type of ELF file from the target triple encoded in the object file
   /// or by inspecting the ELF header
diff --git a/include/eld/Input/SearchDirs.h b/include/eld/Input/SearchDirs.h
index 549ad51bc..5a2033dbe 100644
--- a/include/eld/Input/SearchDirs.h
+++ b/include/eld/Input/SearchDirs.h
@@ -35,6 +35,8 @@ class ELDDirectory;
  *  @see ELDDirectory.
  */
 class SearchDirs {
+public:
+  static std::string getTypeName() { return "SearchDirs"; }
   static const std::string MainExecutablePath;
 
 public:
diff --git a/include/eld/Input/SymDefFile.h b/include/eld/Input/SymDefFile.h
index b602eb4db..f9978bb70 100644
--- a/include/eld/Input/SymDefFile.h
+++ b/include/eld/Input/SymDefFile.h
@@ -11,6 +11,9 @@
 namespace eld {
 
 class SymDefFile : public InputFile {
+public:
+  static std::string getTypeName() { return "SymDefFile"; }
+
 public:
   SymDefFile(Input *I, DiagnosticEngine *DiagEngine);
 
diff --git a/include/eld/Input/ZOption.h b/include/eld/Input/ZOption.h
index d0a5a4ac7..df4a879b7 100644
--- a/include/eld/Input/ZOption.h
+++ b/include/eld/Input/ZOption.h
@@ -22,6 +22,9 @@ namespace eld {
  *  \brief The -z options for GNU ld compatibility.
  */
 class ZOption {
+public:
+  static std::string getTypeName() { return "ZOption"; }
+
 public:
   enum ZOptionKind {
     CombReloc,
diff --git a/include/eld/LayoutMap/LDYAML.h b/include/eld/LayoutMap/LDYAML.h
index 446238709..78ab4bf67 100644
--- a/include/eld/LayoutMap/LDYAML.h
+++ b/include/eld/LayoutMap/LDYAML.h
@@ -14,20 +14,28 @@
 namespace eld {
 namespace LDYAML {
 struct Header {
+public:
+  static std::string getTypeName() { return "Header"; }
   std::string Architecture;
   std::string Emulation;
   std::string AddressSize;
   llvm::yaml::Hex64 ABIPageSize;
 };
 struct Version {
+public:
+  static std::string getTypeName() { return "Version"; }
   std::string VendorVersion;
   std::string ELDVersion;
 };
 struct ArchiveRecord {
+public:
+  static std::string getTypeName() { return "ArchiveRecord"; }
   std::string Origin;
   std::string Referred;
 };
 struct Common {
+public:
+  static std::string getTypeName() { return "Common"; }
   std::string Name;
   llvm::yaml::Hex32 Size;
   std::string InputPath;
@@ -35,6 +43,8 @@ struct Common {
 };
 
 struct LinkStats {
+public:
+  static std::string getTypeName() { return "LinkStats"; }
   std::string Name;
   uint64_t Count;
 };
@@ -42,6 +52,8 @@ struct LinkStats {
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolType)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolScope)
 struct Symbol {
+public:
+  static std::string getTypeName() { return "Symbol"; }
   std::string Name;
   SymbolType Type;
   SymbolScope Scope;
@@ -50,16 +62,22 @@ struct Symbol {
 };
 // Display Input file if it is used or not.
 struct InputFile {
+public:
+  static std::string getTypeName() { return "InputFile"; }
   virtual ~InputFile() {};
   virtual void mapping(llvm::yaml::IO &IO) = 0;
 };
 LLVM_YAML_STRONG_TYPEDEF(bool, InputUsed)
 struct RegularInput : public InputFile {
+public:
+  static std::string getTypeName() { return "RegularInput"; }
   virtual void mapping(llvm::yaml::IO &IO) override;
   std::string Name;
   InputUsed Used;
 };
 struct Archive : public InputFile {
+public:
+  static std::string getTypeName() { return "Archive"; }
   virtual void mapping(llvm::yaml::IO &IO) override;
   std::string Name;
   InputUsed Used;
@@ -68,6 +86,8 @@ struct Archive : public InputFile {
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, Permissions)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SectionType)
 struct Content {
+public:
+  static std::string getTypeName() { return "Content"; }
   enum Kind {
     Assignment,
     LinkerScriptRule,
@@ -80,6 +100,8 @@ struct Content {
   Kind ContentKind;
 };
 struct Assignment : public Content {
+public:
+  static std::string getTypeName() { return "Assignment"; }
   virtual void mapping(llvm::yaml::IO &IO) override;
   static bool classof(const Content *C) {
     return C->ContentKind == Kind::Assignment;
@@ -90,6 +112,8 @@ struct Assignment : public Content {
 };
 
 struct LinkerScriptRule : public Content {
+public:
+  static std::string getTypeName() { return "LinkerScriptRule"; }
   virtual void mapping(llvm::yaml::IO &IO) override;
   static bool classof(const Content *C) {
     return C->ContentKind == Kind::LinkerScriptRule;
@@ -98,6 +122,8 @@ struct LinkerScriptRule : public Content {
 };
 
 struct Padding : public Content {
+public:
+  static std::string getTypeName() { return "Padding"; }
   virtual void mapping(llvm::yaml::IO &IO) override;
   static bool classof(const Content *C) {
     return C->ContentKind == Kind::Padding;
@@ -107,6 +133,8 @@ struct Padding : public Content {
   llvm::yaml::Hex64 PaddingValue;
 };
 struct InputSection : public Content {
+public:
+  static std::string getTypeName() { return "InputSection"; }
   virtual void mapping(llvm::yaml::IO &IO) override;
   static bool classof(const Content *C) {
     return C->ContentKind == Kind::InputSection;
@@ -123,10 +151,14 @@ struct InputSection : public Content {
 };
 
 struct InputBitcodeSection : public InputSection {
+public:
+  static std::string getTypeName() { return "InputBitcodeSection"; }
   virtual void mapping(llvm::yaml::IO &IO) override;
   std::string BitcodeOrigin;
 };
 struct OutputSection : public Content {
+public:
+  static std::string getTypeName() { return "OutputSection"; }
   virtual void mapping(llvm::yaml::IO &IO) override;
   static bool classof(const Content *C) {
     return C->ContentKind == Kind::OutputSection;
@@ -141,12 +173,16 @@ struct OutputSection : public Content {
 };
 
 struct SimpleSymbol {
+public:
+  static std::string getTypeName() { return "SimpleSymbol"; }
   std::string Name;
   SymbolType Type;
   llvm::yaml::Hex64 Size;
 };
 
 struct Reuse {
+public:
+  static std::string getTypeName() { return "Reuse"; }
   std::string From;
   std::vector<SimpleSymbol> Symbols;
   std::string FromFile;
@@ -154,6 +190,8 @@ struct Reuse {
 };
 
 struct Trampoline {
+public:
+  static std::string getTypeName() { return "Trampoline"; }
   std::string Name;
   std::string From;
   std::vector<SimpleSymbol> FromSymbols;
@@ -167,6 +205,8 @@ struct Trampoline {
 };
 
 struct TrampolineInfo {
+public:
+  static std::string getTypeName() { return "TrampolineInfo"; }
   virtual void mapping(llvm::yaml::IO &IO);
   std::string OutputSectionName;
   std::vector<Trampoline> Trampolines;
@@ -174,12 +214,16 @@ struct TrampolineInfo {
 };
 
 struct CommandLineDefault {
+public:
+  static std::string getTypeName() { return "CommandLineDefault"; }
   std::string Name;
   std::string Value;
   std::string Description;
 };
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, CodeGenType)
 struct DiscardedSection {
+public:
+  static std::string getTypeName() { return "DiscardedSection"; }
   virtual void mapping(llvm::yaml::IO &IO);
   std::string Name;
   SectionType Type;
@@ -195,6 +239,8 @@ struct DiscardedSection {
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SegmentType)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SegmentPermissions)
 struct LoadRegion {
+public:
+  static std::string getTypeName() { return "LoadRegion"; }
   virtual void mapping(llvm::yaml::IO &IO);
   SegmentType Type;
   llvm::yaml::Hex64 VirtualAddress;
@@ -211,6 +257,8 @@ struct LoadRegion {
 
 // Cross Reference Table.
 struct CRef {
+public:
+  static std::string getTypeName() { return "CRef"; }
   virtual void mapping(llvm::yaml::IO &IO);
   std::string SymbolName;
   std::vector<std::string> FileRefs;
@@ -218,6 +266,8 @@ struct CRef {
 };
 
 struct Module {
+public:
+  static std::string getTypeName() { return "Module"; }
   Header ModuleHeader;
   Version ModuleVersion;
   std::vector<eld::LDYAML::ArchiveRecord> ArchiveRecords;
@@ -364,6 +414,8 @@ template <> struct MappingTraits<eld::LDYAML::TrampolineInfo> {
 };
 template <>
 struct MappingTraits<std::shared_ptr<eld::LDYAML::DiscardedSection>> {
+public:
+  static std::string getTypeName() { return "MappingTraits"; }
   static void
   mapping(IO &IO,
           std::shared_ptr<eld::LDYAML::DiscardedSection> &DiscardedSection);
diff --git a/include/eld/LayoutMap/LayoutInfo.h b/include/eld/LayoutMap/LayoutInfo.h
index 253b413f2..9d2af97cf 100644
--- a/include/eld/LayoutMap/LayoutInfo.h
+++ b/include/eld/LayoutMap/LayoutInfo.h
@@ -40,6 +40,8 @@ class Module;
 class Stats;
 
 struct LayoutFragmentInfo {
+public:
+  static std::string getTypeName() { return "LayoutFragmentInfo"; }
   LayoutFragmentInfo(InputFile *F, const ELFSection *Section)
       : ThisInputFile(F), ThisSection(Section) {}
 
@@ -70,6 +72,8 @@ struct LayoutFragmentInfo {
 };
 
 class LayoutInfo {
+public:
+  static std::string getTypeName() { return "LayoutInfo"; }
   static uint32_t LayoutDetail;
 
 public:
@@ -95,6 +99,8 @@ class LayoutInfo {
   };
 
   struct Stats {
+  public:
+    static std::string getTypeName() { return "Stats"; }
     uint64_t NumElfObjectFiles = 0;
     uint64_t NumElfExecutableFiles = 0;
     uint64_t NumLinkerScripts = 0;
@@ -132,6 +138,8 @@ class LayoutInfo {
   };
 
   struct InputSequenceT {
+  public:
+    static std::string getTypeName() { return "InputSequenceT"; }
     InputKindPrefix Prefix;
     Input *Input;
     std::string ArchFlag;
@@ -173,6 +181,8 @@ class LayoutInfo {
 
   // Linker Script support
   struct ScriptInputT {
+  public:
+    static std::string getTypeName() { return "ScriptInputT"; }
     std::string Include;
     std::string Parent;
     bool Found = false;
diff --git a/include/eld/LayoutMap/LinkStats.h b/include/eld/LayoutMap/LinkStats.h
index af7ace8c1..545d5fd83 100644
--- a/include/eld/LayoutMap/LinkStats.h
+++ b/include/eld/LayoutMap/LinkStats.h
@@ -14,6 +14,9 @@
 namespace eld {
 
 class LinkStats {
+public:
+  static std::string getTypeName() { return "LinkStats"; }
+
 public:
   enum Kind : uint8_t { None, Relaxation };
 
diff --git a/include/eld/LayoutMap/TextLayoutPrinter.h b/include/eld/LayoutMap/TextLayoutPrinter.h
index 42bbb7ad0..048e1429d 100644
--- a/include/eld/LayoutMap/TextLayoutPrinter.h
+++ b/include/eld/LayoutMap/TextLayoutPrinter.h
@@ -24,6 +24,9 @@ namespace eld {
 class LinkerConfig;
 
 class TextLayoutPrinter {
+public:
+  static std::string getTypeName() { return "TextLayoutPrinter"; }
+
 public:
   TextLayoutPrinter(LayoutInfo *ThisLayoutInfo);
 
diff --git a/include/eld/LayoutMap/YamlLayoutPrinter.h b/include/eld/LayoutMap/YamlLayoutPrinter.h
index 34143c185..a69badcc7 100644
--- a/include/eld/LayoutMap/YamlLayoutPrinter.h
+++ b/include/eld/LayoutMap/YamlLayoutPrinter.h
@@ -18,12 +18,16 @@
 namespace eld {
 class LinkerConfig;
 struct CommandLineDefault {
+public:
+  static std::string getTypeName() { return "CommandLineDefault"; }
   std::string Name;
   std::string Value;
   llvm::StringRef Desc;
 };
 
 class YamlLayoutPrinter {
+public:
+  static std::string getTypeName() { return "YamlLayoutPrinter"; }
 
 public:
   YamlLayoutPrinter(LayoutInfo *layoutInfo);
diff --git a/include/eld/Object/GroupReader.h b/include/eld/Object/GroupReader.h
index b47c76830..ab939240b 100644
--- a/include/eld/Object/GroupReader.h
+++ b/include/eld/Object/GroupReader.h
@@ -30,6 +30,9 @@ class Node;
  *  the command line options --start-group and --end-group options
  */
 class GroupReader {
+public:
+  static std::string getTypeName() { return "GroupReader"; }
+
 public:
   GroupReader(Module &PModule, ObjectLinker *ObjLinker);
 
diff --git a/include/eld/Object/ObjectBuilder.h b/include/eld/Object/ObjectBuilder.h
index b4cf320db..a13eba18c 100644
--- a/include/eld/Object/ObjectBuilder.h
+++ b/include/eld/Object/ObjectBuilder.h
@@ -41,6 +41,9 @@ class SectionMap;
  *  \brief ObjectBuilder recieve ObjectAction and build the eld::Module.
  */
 class ObjectBuilder {
+public:
+  static std::string getTypeName() { return "ObjectBuilder"; }
+
 public:
   ObjectBuilder(LinkerConfig &PConfig, Module &PTheModule);
 
diff --git a/include/eld/Object/ObjectLinker.h b/include/eld/Object/ObjectLinker.h
index e4e362aa5..85fef9eb5 100644
--- a/include/eld/Object/ObjectLinker.h
+++ b/include/eld/Object/ObjectLinker.h
@@ -65,6 +65,9 @@ class ScriptReader;
 /** \class ObjectLinker
  */
 class ObjectLinker {
+public:
+  static std::string getTypeName() { return "ObjectLinker"; }
+
 public:
   ObjectLinker(LinkerConfig &PConfig, Module &PModule);
 
@@ -335,6 +338,8 @@ class ObjectLinker {
   bool isPostLTOPhase() const { return MPostLtoPhase; }
 
   struct SymbolStats {
+  public:
+    static std::string getTypeName() { return "SymbolStats"; }
     uint64_t Global = 0;
     uint64_t Local = 0;
     uint64_t Weak = 0;
diff --git a/include/eld/Object/OutputSectionEntry.h b/include/eld/Object/OutputSectionEntry.h
index 9c4d2fdb8..1db723b39 100644
--- a/include/eld/Object/OutputSectionEntry.h
+++ b/include/eld/Object/OutputSectionEntry.h
@@ -30,6 +30,9 @@ class RuleContainer;
 class SectionMap;
 
 class OutputSectionEntry {
+public:
+  static std::string getTypeName() { return "OutputSectionEntry"; }
+
 public:
   typedef std::vector<RuleContainer *> InputList;
   typedef std::vector<BranchIsland *>::iterator BranchIslandsIter;
diff --git a/include/eld/Object/RuleContainer.h b/include/eld/Object/RuleContainer.h
index fd0b0285d..2ab728839 100644
--- a/include/eld/Object/RuleContainer.h
+++ b/include/eld/Object/RuleContainer.h
@@ -30,6 +30,9 @@ class OutputSectionEntry;
 class SectionMap;
 
 class RuleContainer {
+public:
+  static std::string getTypeName() { return "RuleContainer"; }
+
 public:
   typedef std::vector<Assignment *> SymbolAssignments;
   typedef SymbolAssignments::iterator sym_iterator;
diff --git a/include/eld/Object/ScriptMemoryRegion.h b/include/eld/Object/ScriptMemoryRegion.h
index 99b83e239..eebdbaa7a 100644
--- a/include/eld/Object/ScriptMemoryRegion.h
+++ b/include/eld/Object/ScriptMemoryRegion.h
@@ -19,6 +19,9 @@ class OutputSectionEntry;
 class MemoryDesc;
 
 class ScriptMemoryRegion {
+public:
+  static std::string getTypeName() { return "ScriptMemoryRegion"; }
+
 public:
   enum MemoryAttributes {
     NoAttributes = 0,
diff --git a/include/eld/Object/SectionMap.h b/include/eld/Object/SectionMap.h
index b2909baf2..f75ecdabe 100644
--- a/include/eld/Object/SectionMap.h
+++ b/include/eld/Object/SectionMap.h
@@ -36,6 +36,9 @@ class Section;
  *  \brief descirbe how to map input sections into output sections
  */
 class SectionMap {
+public:
+  static std::string getTypeName() { return "SectionMap"; }
+
 public:
   typedef std::pair<OutputSectionEntry *, RuleContainer *> mapping;
   typedef std::vector<OutputSectionEntry *> OutputSectionEntryDescList;
diff --git a/include/eld/Plugin/PluginData.h b/include/eld/Plugin/PluginData.h
index a4ce22769..7d4d5c467 100644
--- a/include/eld/Plugin/PluginData.h
+++ b/include/eld/Plugin/PluginData.h
@@ -12,6 +12,9 @@
 namespace eld {
 
 class PluginData {
+public:
+  static std::string getTypeName() { return "PluginData"; }
+
 public:
   explicit PluginData(uint32_t Key, void *Data, std::string Annotation);
 
diff --git a/include/eld/Plugin/PluginManager.h b/include/eld/Plugin/PluginManager.h
index 2c4d31af0..d375de3d4 100644
--- a/include/eld/Plugin/PluginManager.h
+++ b/include/eld/Plugin/PluginManager.h
@@ -20,6 +20,9 @@ class Plugin;
 /// It is used to house plugin related functionalities such as
 /// routines for calling a plugin hook for all plugins.
 class PluginManager {
+public:
+  static std::string getTypeName() { return "PluginManager"; }
+
 public:
   explicit PluginManager(const LinkerScript &LinkerScript,
                          DiagnosticEngine &DiagEngine, bool PrintTimingStats)
diff --git a/include/eld/Plugin/PluginOp.h b/include/eld/Plugin/PluginOp.h
index 384497083..325ba6958 100644
--- a/include/eld/Plugin/PluginOp.h
+++ b/include/eld/Plugin/PluginOp.h
@@ -23,6 +23,9 @@ class RuleContainer;
 class OutputSectionEntry;
 
 class PluginOp {
+public:
+  static std::string getTypeName() { return "PluginOp"; }
+
 public:
   enum PluginOpType : uint8_t {
     ChangeOutputSection,
@@ -56,6 +59,9 @@ class PluginOp {
 };
 
 class ChangeOutputSectionPluginOp : public PluginOp {
+public:
+  static std::string getTypeName() { return "ChangeOutputSectionPluginOp"; }
+
 public:
   ChangeOutputSectionPluginOp(plugin::LinkerWrapper *W, eld::ELFSection *S,
                               std::string OutputSection,
@@ -85,6 +91,9 @@ class ChangeOutputSectionPluginOp : public PluginOp {
 };
 
 class AddChunkPluginOp : public PluginOp {
+public:
+  static std::string getTypeName() { return "AddChunkPluginOp"; }
+
 public:
   AddChunkPluginOp(plugin::LinkerWrapper *W, RuleContainer *Rule,
                    eld::Fragment *F, std::string Annotation);
@@ -105,6 +114,9 @@ class AddChunkPluginOp : public PluginOp {
 };
 
 class RemoveChunkPluginOp : public PluginOp {
+public:
+  static std::string getTypeName() { return "RemoveChunkPluginOp"; }
+
 public:
   RemoveChunkPluginOp(plugin::LinkerWrapper *W, RuleContainer *Rule,
                       eld::Fragment *F, std::string Annotation);
@@ -125,6 +137,9 @@ class RemoveChunkPluginOp : public PluginOp {
 };
 
 class UpdateChunksPluginOp : public PluginOp {
+public:
+  static std::string getTypeName() { return "UpdateChunksPluginOp"; }
+
 public:
   enum Type : uint8_t { Start, End };
 
@@ -149,6 +164,9 @@ class UpdateChunksPluginOp : public PluginOp {
 };
 
 class RemoveSymbolPluginOp : public PluginOp {
+public:
+  static std::string getTypeName() { return "RemoveSymbolPluginOp"; }
+
 public:
   RemoveSymbolPluginOp(plugin::LinkerWrapper *W, std::string Annotation,
                        const eld::ResolveInfo *S);
@@ -166,6 +184,9 @@ class RemoveSymbolPluginOp : public PluginOp {
 };
 
 class RelocationDataPluginOp : public PluginOp {
+public:
+  static std::string getTypeName() { return "RelocationDataPluginOp"; }
+
 public:
   RelocationDataPluginOp(plugin::LinkerWrapper *W, const eld::Relocation *R,
                          const std::string &Annotation = {});
@@ -184,6 +205,9 @@ class RelocationDataPluginOp : public PluginOp {
 };
 
 class UpdateLinkStatsPluginOp : public PluginOp {
+public:
+  static std::string getTypeName() { return "UpdateLinkStatsPluginOp"; }
+
 public:
   UpdateLinkStatsPluginOp(plugin::LinkerWrapper *W, const std::string &StatName,
                           const std::string &Annotation);
@@ -197,6 +221,9 @@ class UpdateLinkStatsPluginOp : public PluginOp {
 };
 
 class UpdateRulePluginOp : public PluginOp {
+public:
+  static std::string getTypeName() { return "UpdateRulePluginOp"; }
+
 public:
   UpdateRulePluginOp(plugin::LinkerWrapper *W, RuleContainer *Rule,
                      eld::ELFSection *S, const std::string &Annotation);
@@ -215,6 +242,9 @@ class UpdateRulePluginOp : public PluginOp {
 };
 
 class ResetOffsetPluginOp : public PluginOp {
+public:
+  static std::string getTypeName() { return "ResetOffsetPluginOp"; }
+
 public:
   ResetOffsetPluginOp(plugin::LinkerWrapper *W, const OutputSectionEntry *O,
                       uint32_t OldOffset, const std::string &Annotation = {});
diff --git a/include/eld/PluginAPI/ControlFileSizePlugin.h b/include/eld/PluginAPI/ControlFileSizePlugin.h
index 0bec169b1..62f49a601 100644
--- a/include/eld/PluginAPI/ControlFileSizePlugin.h
+++ b/include/eld/PluginAPI/ControlFileSizePlugin.h
@@ -12,6 +12,9 @@
 namespace eld::plugin {
 
 class DLL_A_EXPORT ControlFileSizePlugin : public Plugin {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   /* Constructor */
   ControlFileSizePlugin(std::string Name)
diff --git a/include/eld/PluginAPI/ControlMemorySizePlugin.h b/include/eld/PluginAPI/ControlMemorySizePlugin.h
index ef30e72a2..8f881adf6 100644
--- a/include/eld/PluginAPI/ControlMemorySizePlugin.h
+++ b/include/eld/PluginAPI/ControlMemorySizePlugin.h
@@ -12,6 +12,9 @@
 namespace eld::plugin {
 
 class DLL_A_EXPORT ControlMemorySizePlugin : public Plugin {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   /* Constructor */
   ControlMemorySizePlugin(std::string Name)
diff --git a/include/eld/PluginAPI/DWARF.h b/include/eld/PluginAPI/DWARF.h
index edcc43da2..f1b25fdb6 100644
--- a/include/eld/PluginAPI/DWARF.h
+++ b/include/eld/PluginAPI/DWARF.h
@@ -35,6 +35,8 @@ struct DLL_A_EXPORT InputFile;
 
 // A class that can parse information from debug sections in DWARF format
 struct DLL_A_EXPORT DWARFInfo {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
   explicit DWARFInfo(llvm::DWARFContext *DC);
 
@@ -62,6 +64,8 @@ struct DLL_A_EXPORT DWARFInfo {
 
 // A class that can parse DWARF Compile Unit
 struct DLL_A_EXPORT DWARFUnit {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit DWARFUnit(llvm::DWARFUnit *Unit);
 
   ///
@@ -84,6 +88,8 @@ struct DLL_A_EXPORT DWARFUnit {
 
 // A class that can parse DWARF Compile Unit
 struct DLL_A_EXPORT DWARFDie {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
   explicit DWARFDie(llvm::DWARFUnit *U, llvm::DWARFDebugInfoEntry *Entry);
 
@@ -276,6 +282,8 @@ struct DLL_A_EXPORT DWARFDie {
 
 /// Represents DWARF Attributes
 struct DLL_A_EXPORT DWARFAttribute {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
   /// Create a DWARFAttribute from llvm::DWARFAttribute
   explicit DWARFAttribute(const llvm::DWARFAttribute *Attribute);
@@ -300,6 +308,8 @@ struct DLL_A_EXPORT DWARFAttribute {
 
 /// The associated value for an attribute
 struct DLL_A_EXPORT DWARFValue {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit DWARFValue(const llvm::DWARFFormValue *V);
 
   /// If the value for this DWARF attribute is a string, return it. Otherwise
diff --git a/include/eld/PluginAPI/DiagnosticBuilder.h b/include/eld/PluginAPI/DiagnosticBuilder.h
index d4314eede..bf303fb98 100644
--- a/include/eld/PluginAPI/DiagnosticBuilder.h
+++ b/include/eld/PluginAPI/DiagnosticBuilder.h
@@ -41,6 +41,9 @@ namespace eld::plugin {
 //  } // diagnostic is emitted at this point.
 /// \endcode
 class DLL_A_EXPORT DiagnosticBuilder {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   DiagnosticBuilder(eld::MsgHandler *msgHandler);
   /// DiagnosticBuilder should not be copied.
diff --git a/include/eld/PluginAPI/DiagnosticEntry.h b/include/eld/PluginAPI/DiagnosticEntry.h
index fee52d58a..741a427e7 100644
--- a/include/eld/PluginAPI/DiagnosticEntry.h
+++ b/include/eld/PluginAPI/DiagnosticEntry.h
@@ -22,6 +22,9 @@ namespace eld::plugin {
 /// If no 'Severity' is specified, then the default severity associated
 /// with a diagnostic ID is used.
 class DLL_A_EXPORT DiagnosticEntry {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   // The order of values in Severity enum should be from
   // least severe to most severe.
@@ -81,6 +84,9 @@ class DLL_A_EXPORT DiagnosticEntry {
 /// ErrorDiagnosticEntry subclass allows to easily create error diagnostic
 /// entry.
 class DLL_A_EXPORT ErrorDiagnosticEntry : public DiagnosticEntry {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   ErrorDiagnosticEntry() = default;
   explicit ErrorDiagnosticEntry(DiagIDType id,
@@ -93,6 +99,9 @@ class DLL_A_EXPORT ErrorDiagnosticEntry : public DiagnosticEntry {
 /// WarningDiagnosticEntry subclass allows to easily create warning diagnostic
 /// entry.
 class DLL_A_EXPORT WarningDiagnosticEntry : public DiagnosticEntry {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   WarningDiagnosticEntry() = default;
   explicit WarningDiagnosticEntry(DiagIDType id,
@@ -106,6 +115,9 @@ class DLL_A_EXPORT WarningDiagnosticEntry : public DiagnosticEntry {
 /// FatalDiagnosticEntry subclass allows to easily create fatal diagnostic
 /// entry.
 class DLL_A_EXPORT FatalDiagnosticEntry : public DiagnosticEntry {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   FatalDiagnosticEntry() = default;
   explicit FatalDiagnosticEntry(DiagIDType id,
@@ -118,6 +130,9 @@ class DLL_A_EXPORT FatalDiagnosticEntry : public DiagnosticEntry {
 /// VerboseDiagnosticEntry subclass allows to easily create verbose diagnostic
 /// entry.
 class DLL_A_EXPORT VerboseDiagnosticEntry : public DiagnosticEntry {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   VerboseDiagnosticEntry() = default;
   explicit VerboseDiagnosticEntry(DiagIDType id,
@@ -131,6 +146,9 @@ class DLL_A_EXPORT VerboseDiagnosticEntry : public DiagnosticEntry {
 /// NoteDiagnosticEntry subclass allows to easily create note diagnostic
 /// entry.
 class DLL_A_EXPORT NoteDiagnosticEntry : public DiagnosticEntry {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   NoteDiagnosticEntry() = default;
   explicit NoteDiagnosticEntry(DiagIDType id,
diff --git a/include/eld/PluginAPI/Expected.h b/include/eld/PluginAPI/Expected.h
index 15e8f6733..d3b5cc5a0 100644
--- a/include/eld/PluginAPI/Expected.h
+++ b/include/eld/PluginAPI/Expected.h
@@ -70,6 +70,9 @@ namespace eld {
 // clang-format on
 template <class T, class U = std::unique_ptr<plugin::DiagnosticEntry>>
 class Expected {
+public:
+  static std::string getTypeName() { return "Expected"; }
+
 public:
   Expected() = default;
   Expected(const Expected &) = default;
diff --git a/include/eld/PluginAPI/LayoutADT.h b/include/eld/PluginAPI/LayoutADT.h
index 470908578..81d3ea727 100644
--- a/include/eld/PluginAPI/LayoutADT.h
+++ b/include/eld/PluginAPI/LayoutADT.h
@@ -18,6 +18,8 @@ struct DLL_A_EXPORT LinkerConfig;
 struct DLL_A_EXPORT MapHeader;
 
 struct DLL_A_EXPORT MapHeader {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit MapHeader(const plugin::LinkerConfig &Config);
   std::string getVendorName() const;
   std::string getVendorVersion() const;
@@ -32,6 +34,8 @@ struct DLL_A_EXPORT MapHeader {
 /// Padding details at section start, fragment and
 /// between rules.
 struct DLL_A_EXPORT Padding {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   uint64_t startOffset = 0;
   uint64_t size = 0;
   uint64_t fillValue = 0;
diff --git a/include/eld/PluginAPI/LayoutWrapper.h b/include/eld/PluginAPI/LayoutWrapper.h
index 51b6a9442..c4b5bd713 100644
--- a/include/eld/PluginAPI/LayoutWrapper.h
+++ b/include/eld/PluginAPI/LayoutWrapper.h
@@ -24,6 +24,9 @@ struct OutputSection;
 /// LayoutWrapper allows plugins to get the link-time information to populate
 /// layout data in a map file.
 class DLL_A_EXPORT LayoutWrapper {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   explicit LayoutWrapper(const LinkerWrapper &Linker);
 
diff --git a/include/eld/PluginAPI/LinkerPlugin.h b/include/eld/PluginAPI/LinkerPlugin.h
index 65f6c8de3..43de63eab 100644
--- a/include/eld/PluginAPI/LinkerPlugin.h
+++ b/include/eld/PluginAPI/LinkerPlugin.h
@@ -27,6 +27,9 @@ namespace eld::plugin {
 class LTOModule;
 
 class DLL_A_EXPORT LinkerPlugin : public PluginBase {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   LinkerPlugin(const std::string &name)
       : PluginBase(PluginBase::Type::LinkerPlugin, name) {}
diff --git a/include/eld/PluginAPI/LinkerPluginConfig.h b/include/eld/PluginAPI/LinkerPluginConfig.h
index 4a32e295b..76815a1cd 100644
--- a/include/eld/PluginAPI/LinkerPluginConfig.h
+++ b/include/eld/PluginAPI/LinkerPluginConfig.h
@@ -22,6 +22,9 @@ struct DLL_A_EXPORT Use;
 /// registered relocation type. Relocation types must be registered via
 /// LinkerWrapper::RegisterReloc.
 class DLL_A_EXPORT LinkerPluginConfig {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   explicit LinkerPluginConfig(plugin::Plugin *);
 
diff --git a/include/eld/PluginAPI/LinkerScript.h b/include/eld/PluginAPI/LinkerScript.h
index f6e7ca0a3..bb6053e06 100644
--- a/include/eld/PluginAPI/LinkerScript.h
+++ b/include/eld/PluginAPI/LinkerScript.h
@@ -77,6 +77,8 @@ struct DLL_A_EXPORT Sections;
 /// \class ScriptCommand
 /// \brief Base class for all linker script commands.
 struct DLL_A_EXPORT ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   /// \enum CommmandKind - represents the kind of commands supported
   enum CommandKind : uint8_t {
     Assignment,
@@ -343,6 +345,8 @@ struct DLL_A_EXPORT ScriptCommand {
 /// \class PHDRDescriptor
 /// \brief This class represents each segment and the corresponding members
 struct DLL_A_EXPORT PHDRDescriptor : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   /// Constructor
   explicit PHDRDescriptor(eld::PhdrDesc *PhdrDesc);
 
@@ -382,6 +386,8 @@ struct DLL_A_EXPORT PHDRDescriptor : public ScriptCommand {
 ///             [ FLAGS ( flags ) ] ;
 ///  }
 struct DLL_A_EXPORT PHDRS : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   /// Constructor
   explicit PHDRS(eld::PhdrsCmd *PhdrsCmd);
 
@@ -421,6 +427,8 @@ struct DLL_A_EXPORT PHDRS : public ScriptCommand {
 /// symbol *= expression ;
 /// symbol /= expression ;
 struct DLL_A_EXPORT Assignment : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit Assignment(eld::Assignment *Assignment);
 
   /// \returns true when used in a boolean expression.
@@ -462,6 +470,8 @@ struct DLL_A_EXPORT Assignment : public ScriptCommand {
 ///
 /// \brief Specification :- represented by {
 struct DLL_A_EXPORT EnterScope : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit EnterScope(eld::EnterScopeCmd *EnterScope);
 
   /// \returns true when used in a boolean expression.
@@ -482,6 +492,8 @@ struct DLL_A_EXPORT EnterScope : public ScriptCommand {
 ///
 /// \brief Specification :- represented by }
 struct DLL_A_EXPORT ExitScope : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit ExitScope(eld::ExitScopeCmd *ExitScope);
 
   /// \returns true when used in a boolean expression.
@@ -522,6 +534,8 @@ struct DLL_A_EXPORT ExitScope : public ScriptCommand {
 /// * The address 0.
 
 struct DLL_A_EXPORT Entry : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit Entry(eld::EntryCmd *Entry);
 
   /// \returns true when used in a boolean expression.
@@ -548,6 +562,8 @@ struct DLL_A_EXPORT Entry : public ScriptCommand {
 /// may use EXTERN multiple times. This command has the same effect as the `-u'
 /// command-line option.
 struct DLL_A_EXPORT Extern : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit Extern(eld::ExternCmd *Extern);
 
   /// \returns true when used in a boolean expression.
@@ -574,6 +590,8 @@ struct DLL_A_EXPORT Extern : public ScriptCommand {
 /// are created.
 
 struct DLL_A_EXPORT Group : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit Group(eld::GroupCmd *Group);
 
   /// \returns true when used in a boolean expression.
@@ -600,6 +618,8 @@ struct DLL_A_EXPORT Group : public ScriptCommand {
 /// deep You can place INCLUDE directives at the top level, in MEMORY or
 /// SECTIONS commands, or in output section descriptions
 struct DLL_A_EXPORT Include : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit Include(eld::IncludeCmd *Include);
 
   /// \returns true when used in a boolean expression.
@@ -646,6 +666,8 @@ struct DLL_A_EXPORT Include : public ScriptCommand {
 /// If you use `INPUT (-lfile)', ld will transform the name to libfile.a, as
 /// with the command line argument `-l'.
 struct DLL_A_EXPORT Input : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit Input(eld::InputCmd *Input);
 
   /// \returns true when used in a boolean expression.
@@ -668,6 +690,8 @@ struct DLL_A_EXPORT Input : public ScriptCommand {
 /// memory. You use input section descriptions to tell the linker how to map the
 /// input files into your memory layout.
 struct DLL_A_EXPORT InputSectionSpec : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit InputSectionSpec(eld::InputSectDesc *ISD);
 
   /// \returns true when used in a boolean expression.
@@ -717,6 +741,8 @@ struct DLL_A_EXPORT InputSectionSpec : public ScriptCommand {
 /// names, not input section names.
 
 struct DLL_A_EXPORT NoCrossRefs : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit NoCrossRefs(eld::NoCrossRefsCmd *NoCrossRefs);
 
   /// \returns true when used in a boolean expression.
@@ -742,6 +768,8 @@ struct DLL_A_EXPORT NoCrossRefs : public ScriptCommand {
 /// precedence. You can use the OUTPUT command to define a default name for the
 /// output file other than the usual default of a.out.
 struct DLL_A_EXPORT Output : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit Output(eld::OutputCmd *Output);
 
   /// \returns true when used in a boolean expression.
@@ -763,6 +791,8 @@ struct DLL_A_EXPORT Output : public ScriptCommand {
 /// Specify a particular output machine architecture.
 
 struct DLL_A_EXPORT OutputArch : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit OutputArch(eld::OutputArchCmd *OutputArch);
 
   /// \returns true when used in a boolean expression.
@@ -783,6 +813,8 @@ struct DLL_A_EXPORT OutputArch : public ScriptCommand {
 /// OUTPUT_FORMAT ( name )
 /// Specify output format.
 struct DLL_A_EXPORT OutputFormat : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit OutputFormat(eld::OutputFormatCmd *OutputFormat);
 
   /// \returns true when used in a boolean expression.
@@ -813,6 +845,8 @@ struct DLL_A_EXPORT OutputFormat : public ScriptCommand {
 ///        } [>region] [AT>lma_region] [:phdr :phdr ...] [=fillexp]
 
 struct DLL_A_EXPORT OutputSectionSpec : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit OutputSectionSpec(eld::OutputSectDesc *OSD);
 
   /// \returns true when used in a boolean expression.
@@ -848,6 +882,8 @@ struct DLL_A_EXPORT OutputSectionSpec : public ScriptCommand {
 /// PLUGIN_SECTION_MATCHER
 /// Handle all Linker plugins.
 struct DLL_A_EXPORT Plugin : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit Plugin(eld::PluginCmd *P);
 
   /// \returns true when used in a boolean expression.
@@ -874,6 +910,8 @@ struct DLL_A_EXPORT Plugin : public ScriptCommand {
 /// command-line option are searched first.
 
 struct DLL_A_EXPORT SearchDir : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit SearchDir(eld::SearchDirCmd *SearchDir);
 
   /// \returns true when used in a boolean expression.
@@ -910,6 +948,8 @@ struct DLL_A_EXPORT SearchDir : public ScriptCommand {
 /// an output section description
 
 struct DLL_A_EXPORT Sections : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit Sections(eld::SectionsCmd *SectionsCmd);
 
   /// \returns true when used in a boolean expression.
@@ -939,6 +979,8 @@ struct DLL_A_EXPORT Sections : public ScriptCommand {
 /// bytes of data in an output section. These commands include BYTE, SHORT,
 /// LONG, QUAD and SQUAD.
 struct DLL_A_EXPORT OutputSectionData : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit OutputSectionData(eld::OutputSectData *OSD);
 
   /// \returns true if objects contains a command.
@@ -953,6 +995,8 @@ struct DLL_A_EXPORT OutputSectionData : public ScriptCommand {
 
 /// MEMORY command wrapper
 struct DLL_A_EXPORT Memory : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit Memory(eld::MemoryCmd *MemoryCmd);
 
   operator bool() const { return m_MemoryCmd != nullptr; }
@@ -967,6 +1011,8 @@ struct DLL_A_EXPORT Memory : public ScriptCommand {
 
 /// REGION_ALIAS command wrapper
 struct DLL_A_EXPORT RegionAlias : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit RegionAlias(eld::RegionAlias *RegionAliasCmd);
 
   operator bool() const { return m_RegionAlias != nullptr; }
@@ -982,6 +1028,8 @@ struct DLL_A_EXPORT RegionAlias : public ScriptCommand {
 /// \brief Handle Linker Script and provide lookup of PHDRS, OutputSections and
 /// Rules
 struct DLL_A_EXPORT LinkerScript {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
   /// Constructor
   explicit LinkerScript(eld::LinkerScript *LinkerScript);
diff --git a/include/eld/PluginAPI/LinkerWrapper.h b/include/eld/PluginAPI/LinkerWrapper.h
index 2a2e24c07..e89463850 100644
--- a/include/eld/PluginAPI/LinkerWrapper.h
+++ b/include/eld/PluginAPI/LinkerWrapper.h
@@ -81,6 +81,9 @@ using AuxiliarySymbolNameMap = std::unordered_map<uint64_t, std::string>;
 /// interface types at all link stages, some APIs are only meaningful for
 /// certain plugin interface types and link stages.
 class DLL_A_EXPORT LinkerWrapper {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
 
   /// Link modes.
@@ -102,6 +105,8 @@ class DLL_A_EXPORT LinkerWrapper {
   /// chunk: The added chunk
   /// rule: Rule to which it was added.
   struct DLL_A_EXPORT UnbalancedChunkMove {
+  public:
+    static std::string getTypeName() { return "DLL_A_EXPORT"; }
     Chunk chunk;
     LinkerScriptRule rule;
   };
diff --git a/include/eld/PluginAPI/OutputSectionIteratorPlugin.h b/include/eld/PluginAPI/OutputSectionIteratorPlugin.h
index ed4fa46a0..6217ec0a6 100644
--- a/include/eld/PluginAPI/OutputSectionIteratorPlugin.h
+++ b/include/eld/PluginAPI/OutputSectionIteratorPlugin.h
@@ -12,6 +12,9 @@
 namespace eld::plugin {
 
 class DLL_A_EXPORT OutputSectionIteratorPlugin : public Plugin {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   /* Constructor */
   OutputSectionIteratorPlugin(std::string Name)
diff --git a/include/eld/PluginAPI/PluginADT.h b/include/eld/PluginAPI/PluginADT.h
index 59192e947..7422f2ac6 100644
--- a/include/eld/PluginAPI/PluginADT.h
+++ b/include/eld/PluginAPI/PluginADT.h
@@ -78,6 +78,8 @@ struct DLL_A_EXPORT LinkerConfig;
 /// chunk.
 
 struct DLL_A_EXPORT Chunk {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
   explicit Chunk(eld::Fragment *F) : m_Fragment(F) {}
 
@@ -113,6 +115,8 @@ struct DLL_A_EXPORT Chunk {
   /// Returns true if the chunks A and B originates
   /// from different input sections; Otherwise returns false.
   struct DEPRECATED DLL_A_EXPORT Compare final {
+  public:
+    static std::string getTypeName() { return "DEPRECATED"; }
     bool operator()(const Chunk &A, const Chunk &B) const;
   };
 
@@ -181,6 +185,8 @@ struct DLL_A_EXPORT Chunk {
 /// strings. For a Chunk to be a MergeStringChunk, isMergeableString() must be
 /// true for that Chunk.
 struct DLL_A_EXPORT MergeStringChunk : public Chunk {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   MergeStringChunk(eld::Fragment *F) : Chunk(F) {}
 
   /// Return the strings contained in this Chunk in a vector
@@ -191,6 +197,8 @@ struct DLL_A_EXPORT MergeStringChunk : public Chunk {
 /// section that has the flags SHF_STRINGS & SHF_MERGE, and alignment and entry
 /// size of 1.
 struct DLL_A_EXPORT MergeableString {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit MergeableString(const eld::MergeableString *S);
   /// return the null-terminated string that this MergeableString represents.
   const char *getString() const;
@@ -238,6 +246,8 @@ struct DLL_A_EXPORT MergeableString {
 /// If two LinkerScriptRule objects have the same underlying RuleContainer
 /// object, then both the objects represent the same rule.
 struct DLL_A_EXPORT LinkerScriptRule final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
   enum State : uint8_t { Empty, NoChunk, DuplicateChunk, NotEmpty, Ok };
 
@@ -410,6 +420,8 @@ struct DLL_A_EXPORT LinkerScriptRule final {
 /// Segment is a handler for an ELF Segment. A Segment object can be used
 /// to inspect Segment properties and their associated OutputSections.
 struct DLL_A_EXPORT Segment final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
   explicit Segment(eld::ELFSegment *S) : S(S) {}
 
@@ -480,6 +492,9 @@ struct DLL_A_EXPORT Segment final {
 /// Far-function calls are function calls where the function address
 /// cannot be represented in the default function call instruction.
 class DLL_A_EXPORT Stub {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   explicit Stub(const eld::BranchIsland *pBI) : BI(pBI) {}
 
@@ -509,6 +524,8 @@ class DLL_A_EXPORT Stub {
 /// OutputSectionEntry object, then they both represent the same
 /// output section.
 struct DLL_A_EXPORT OutputSection final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit OutputSection(eld::OutputSectionEntry *O) : m_OutputSection(O) {}
 
   /// Returns the name of the output section.
@@ -650,6 +667,8 @@ struct DLL_A_EXPORT OutputSection final {
 /// have the same underlying Section object, then they both represents the
 /// same section.
 struct DLL_A_EXPORT Section {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   // TODO: What do each of these types means? Where is SectionType used?
   enum SectionType : uint8_t { Default, Padding };
 
@@ -852,6 +871,8 @@ struct DLL_A_EXPORT Section {
 /// Block represents output sections and their content.
 // TODO:
 struct DLL_A_EXPORT Block final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   Block() : Data(nullptr), Size(0), Address(0), Alignment(1) {}
   const uint8_t *Data; ///< Data passed to the plugin
   uint32_t Size;       ///< Size of the data in bytes.
@@ -870,6 +891,8 @@ struct DLL_A_EXPORT Block final {
 /// If two Use objects have the same underlying relocation objects,
 /// then the two Use objects represents the same Use.
 struct DLL_A_EXPORT Use final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   /// Symbol status.
   enum Status : uint8_t { Ok, SymbolDoesNotExist, Error };
   explicit Use(eld::Relocation *R) : m_Relocation(R) {}
@@ -966,6 +989,8 @@ struct DLL_A_EXPORT Use final {
 /// Symbol objects have the same underlying ResolveInfo object, then
 /// they both represent the same symbol.
 struct DLL_A_EXPORT Symbol final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
   enum Binding { Global = 0, Weak = 1, Local = 2 };
   enum Kind { Undefined = 0, Define = 1, Common = 2 };
@@ -1084,6 +1109,8 @@ struct DLL_A_EXPORT Symbol final {
 /// INIFile represents an ini configuration file. It provides APIs
 /// to easily inspect and modify the INI configuration.
 struct DLL_A_EXPORT INIFile final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
   enum ErrorCode { Success, FileDoesNotExist, ReadError, WriteError };
 
@@ -1174,6 +1201,9 @@ struct DLL_A_EXPORT INIFile final {
 /// E.g. Adding data to a tar file using the plugin::TarWriter's
 /// addBufferToTar(eld::Expected<plugin::MemoryBuffer> buffer) function.
 class DLL_A_EXPORT MemoryBuffer final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 private:
   std::unique_ptr<eld::MemoryArea> getBuffer();
 
@@ -1221,6 +1251,8 @@ class DLL_A_EXPORT MemoryBuffer final {
 /// with. An InputFile object can be used to inspect input file properties,
 /// and contents.
 struct DLL_A_EXPORT InputFile {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit InputFile(eld::InputFile *I) : m_InputFile(I) {}
 
   /// Returns the file name of the input file if the object has an
@@ -1326,6 +1358,8 @@ struct DLL_A_EXPORT InputFile {
 
 /// An interface to represent a bitcode file to retrieve the LTO Input file.
 struct DLL_A_EXPORT BitcodeFile final : public InputFile {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
   explicit BitcodeFile(eld::BitcodeFile &F);
 
@@ -1336,6 +1370,8 @@ struct DLL_A_EXPORT BitcodeFile final : public InputFile {
 };
 
 struct DLL_A_EXPORT DynamicLibrary final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   void *Handle;
   std::string Path;
 };
@@ -1343,6 +1379,8 @@ struct DLL_A_EXPORT DynamicLibrary final {
 /// PluginData provide a way for storing data and communicating between plugins.
 // TODO: Add a demo that shows the usage of PluginData.
 struct DLL_A_EXPORT PluginData final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit PluginData(eld::PluginData *D) : m_Data(D) {}
 
   void *getData() const;
@@ -1373,6 +1411,8 @@ struct DLL_A_EXPORT PluginData final {
 
 /// Plugin Profiling support
 struct DLL_A_EXPORT AutoTimer final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit AutoTimer(llvm::Timer *T);
 
   /// Start Timer
@@ -1404,6 +1444,8 @@ struct DLL_A_EXPORT AutoTimer final {
 };
 
 struct DLL_A_EXPORT Timer final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   Timer(llvm::Timer *T);
 
   /// Start Timer
@@ -1439,6 +1481,8 @@ struct DLL_A_EXPORT Timer final {
 // FIXME: This class do not provide much functionality to handle
 // relocations.
 struct DLL_A_EXPORT RelocationHandler final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
   RelocationHandler(eld::Relocator *R);
 
@@ -1478,6 +1522,9 @@ struct DLL_A_EXPORT RelocationHandler final {
 };
 
 class DLL_A_EXPORT InputSymbol final {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   InputSymbol();
 
@@ -1515,6 +1562,8 @@ class DLL_A_EXPORT InputSymbol final {
 /// LinkerConfig houses functions for plugins to access linker configurations
 /// and options.
 struct DLL_A_EXPORT LinkerConfig {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit LinkerConfig(const eld::LinkerConfig &Config);
   std::string getTargetCPU() const;
   std::string getArchName() const;
diff --git a/include/eld/PluginAPI/PluginConfig.h b/include/eld/PluginAPI/PluginConfig.h
index 7cf448f14..29b20e670 100644
--- a/include/eld/PluginAPI/PluginConfig.h
+++ b/include/eld/PluginAPI/PluginConfig.h
@@ -15,6 +15,8 @@ namespace eld {
 namespace LinkerPlugin {
 
 struct GlobalPlugin {
+public:
+  static std::string getTypeName() { return "GlobalPlugin"; }
   plugin::PluginBase::Type PluginType;
   std::string PluginName;
   std::string LibraryName;
@@ -22,6 +24,8 @@ struct GlobalPlugin {
 };
 
 struct OutputSectionPlugin {
+public:
+  static std::string getTypeName() { return "OutputSectionPlugin"; }
   plugin::PluginBase::Type PluginType;
   std::string OutputSection;
   std::string PluginName;
@@ -30,6 +34,8 @@ struct OutputSectionPlugin {
 };
 
 struct Config {
+public:
+  static std::string getTypeName() { return "Config"; }
   std::vector<eld::LinkerPlugin::GlobalPlugin> GlobalPlugins;
   std::vector<eld::LinkerPlugin::OutputSectionPlugin> OutputSectionPlugins;
 };
diff --git a/include/eld/PluginAPI/SectionIteratorPlugin.h b/include/eld/PluginAPI/SectionIteratorPlugin.h
index 90f458866..f7fd30af9 100644
--- a/include/eld/PluginAPI/SectionIteratorPlugin.h
+++ b/include/eld/PluginAPI/SectionIteratorPlugin.h
@@ -12,6 +12,9 @@
 namespace eld::plugin {
 
 class DLL_A_EXPORT SectionIteratorPlugin : public Plugin {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   /* Constructor */
   SectionIteratorPlugin(std::string Name)
diff --git a/include/eld/PluginAPI/SectionMatcherPlugin.h b/include/eld/PluginAPI/SectionMatcherPlugin.h
index ae569d34f..2dfbac87c 100644
--- a/include/eld/PluginAPI/SectionMatcherPlugin.h
+++ b/include/eld/PluginAPI/SectionMatcherPlugin.h
@@ -12,6 +12,9 @@
 namespace eld::plugin {
 
 class DLL_A_EXPORT SectionMatcherPlugin : public Plugin {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   /* Constructor */
   SectionMatcherPlugin(std::string Name)
diff --git a/include/eld/PluginAPI/SmallJSON.h b/include/eld/PluginAPI/SmallJSON.h
index 61d3d95a0..c3e4961d4 100644
--- a/include/eld/PluginAPI/SmallJSON.h
+++ b/include/eld/PluginAPI/SmallJSON.h
@@ -24,6 +24,9 @@ struct DLL_A_EXPORT SmallJSONValue;
 /// A Class representing a value representible in JSON. Includes Objects,
 /// Arrays, boolean, floating point, integral, string, and null types
 struct DLL_A_EXPORT SmallJSONValue {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   /// Create a SmallJSONValue from a SmallJSONObject
   SmallJSONValue(SmallJSONObject &&Obj);
@@ -66,6 +69,8 @@ struct DLL_A_EXPORT SmallJSONValue {
 /// This class is append only. Items will appear in the order in which they were
 /// inserted
 struct DLL_A_EXPORT SmallJSONObject {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
 public:
   /// Move constructor
@@ -96,6 +101,8 @@ struct DLL_A_EXPORT SmallJSONObject {
 /// An append-only class represeting a heterogenous array of JSON values. Items
 /// are stored in insertion order.
 struct DLL_A_EXPORT SmallJSONArray {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
 
 public:
   /// Move constructor
diff --git a/include/eld/PluginAPI/TarWriter.h b/include/eld/PluginAPI/TarWriter.h
index f3f5be4be..c0c738422 100644
--- a/include/eld/PluginAPI/TarWriter.h
+++ b/include/eld/PluginAPI/TarWriter.h
@@ -21,6 +21,8 @@ class LinkerWrapper;
 
 /// A utility class for creating tar archives
 class DLL_A_EXPORT TarWriter {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
   explicit TarWriter(std::unique_ptr<llvm::TarWriter> TW);
 
 public:
diff --git a/include/eld/PluginAPI/ThreadPool.h b/include/eld/PluginAPI/ThreadPool.h
index 189ba0767..5fa839af7 100644
--- a/include/eld/PluginAPI/ThreadPool.h
+++ b/include/eld/PluginAPI/ThreadPool.h
@@ -22,6 +22,9 @@ namespace eld::plugin {
 /// The pool keeps a vector of threads alive, waiting on a condition
 /// variable for some work to become available.
 class DLL_A_EXPORT ThreadPool {
+public:
+  static std::string getTypeName() { return "DLL_A_EXPORT"; }
+
 public:
   using TaskTy = std::function<void()>;
 
diff --git a/include/eld/Readers/ArchiveParser.h b/include/eld/Readers/ArchiveParser.h
index c2006f7e0..8725aaff7 100644
--- a/include/eld/Readers/ArchiveParser.h
+++ b/include/eld/Readers/ArchiveParser.h
@@ -22,6 +22,9 @@ class Module;
 class ResolveInfo;
 
 class ArchiveParser final {
+public:
+  static std::string getTypeName() { return "ArchiveParser"; }
+
 public:
   explicit ArchiveParser(Module &module) : m_Module(module) {};
 
@@ -42,6 +45,8 @@ class ArchiveParser final {
   eld::Expected<uint32_t> parseFile(InputFile &inputFile) const;
 
   struct ArchiveSymbol {
+  public:
+    static std::string getTypeName() { return "ArchiveSymbol"; }
     uint64_t ChildOffset = 0;
     llvm::StringRef SymbolName;
 
diff --git a/include/eld/Readers/BinaryFileParser.h b/include/eld/Readers/BinaryFileParser.h
index 8a727ee82..358086938 100644
--- a/include/eld/Readers/BinaryFileParser.h
+++ b/include/eld/Readers/BinaryFileParser.h
@@ -22,6 +22,9 @@ class Module;
 ///   program: '_binary_${FileName}_start', '_binary_${FileName}_end' and
 ///   '_binary_${FileName}_size'.
 class BinaryFileParser {
+public:
+  static std::string getTypeName() { return "BinaryFileParser"; }
+
 public:
   BinaryFileParser(Module &module) : m_Module(module) {}
 
diff --git a/include/eld/Readers/BitcodeReader.h b/include/eld/Readers/BitcodeReader.h
index cc6d145b7..df6caede0 100644
--- a/include/eld/Readers/BitcodeReader.h
+++ b/include/eld/Readers/BitcodeReader.h
@@ -7,6 +7,8 @@
 #ifndef ELD_READERS_BITCODEREADER_H
 #define ELD_READERS_BITCODEREADER_H
 
+#include <string>
+
 namespace eld::plugin {
 class LinkerPlugin;
 }
@@ -17,6 +19,8 @@ class Module;
 class InputFile;
 
 class BitcodeReader {
+public:
+  static std::string getTypeName() { return "BitcodeReader"; }
 
 public:
   BitcodeReader(Module &);
diff --git a/include/eld/Readers/CommonELFSection.h b/include/eld/Readers/CommonELFSection.h
index 6843abf8b..9d36883a7 100644
--- a/include/eld/Readers/CommonELFSection.h
+++ b/include/eld/Readers/CommonELFSection.h
@@ -16,6 +16,9 @@ namespace eld {
 /// Common section contains a common symbol.
 ///
 class CommonELFSection : public ELFSection {
+public:
+  static std::string getTypeName() { return "CommonELFSection"; }
+
 public:
   CommonELFSection(const std::string &Name, InputFile *I, uint32_t Align)
       : ELFSection(Section::Kind::CommonELF, LDFileFormat::Common, Name,
diff --git a/include/eld/Readers/ELFDynObjParser.h b/include/eld/Readers/ELFDynObjParser.h
index 951086c74..238e12f88 100644
--- a/include/eld/Readers/ELFDynObjParser.h
+++ b/include/eld/Readers/ELFDynObjParser.h
@@ -19,6 +19,9 @@ class Module;
 /// uses an instance of DynamicELFReader<ELFT> to drive the reading
 /// process.
 class ELFDynObjParser {
+public:
+  static std::string getTypeName() { return "ELFDynObjParser"; }
+
 public:
   ELFDynObjParser(Module &);
 
diff --git a/include/eld/Readers/ELFExecObjParser.h b/include/eld/Readers/ELFExecObjParser.h
index 4945117ed..e751d88e2 100644
--- a/include/eld/Readers/ELFExecObjParser.h
+++ b/include/eld/Readers/ELFExecObjParser.h
@@ -14,6 +14,9 @@ class ELFReaderBase;
 class ELFExecutableFileReader;
 
 class ELFExecObjParser {
+public:
+  static std::string getTypeName() { return "ELFExecObjParser"; }
+
 public:
   ELFExecObjParser(Module &);
 
diff --git a/include/eld/Readers/ELFReaderBase.h b/include/eld/Readers/ELFReaderBase.h
index adb9f8ff0..8da16bee5 100644
--- a/include/eld/Readers/ELFReaderBase.h
+++ b/include/eld/Readers/ELFReaderBase.h
@@ -26,6 +26,9 @@ class Module;
 /// ELFReaderBase propagates all the errors to the caller function using
 /// eld::Expected.
 class ELFReaderBase {
+public:
+  static std::string getTypeName() { return "ELFReaderBase"; }
+
 public:
   explicit ELFReaderBase(Module &module, InputFile &inputFile);
 
diff --git a/include/eld/Readers/ELFRelocObjParser.h b/include/eld/Readers/ELFRelocObjParser.h
index ffb87953d..691a97e61 100644
--- a/include/eld/Readers/ELFRelocObjParser.h
+++ b/include/eld/Readers/ELFRelocObjParser.h
@@ -19,6 +19,9 @@ class Module;
 /// uses an instance of RelocELFReader<ELFT> to drive the reading
 /// process.
 class ELFRelocObjParser {
+public:
+  static std::string getTypeName() { return "ELFRelocObjParser"; }
+
 public:
   ELFRelocObjParser(Module &);
 
diff --git a/include/eld/Readers/ELFSection.h b/include/eld/Readers/ELFSection.h
index 04ffb4032..63fa98755 100644
--- a/include/eld/Readers/ELFSection.h
+++ b/include/eld/Readers/ELFSection.h
@@ -28,6 +28,9 @@ class InputFile;
 class Section;
 
 class ELFSectionBase : public Section {
+public:
+  static std::string getTypeName() { return "ELFSectionBase"; }
+
 public:
   virtual ~ELFSectionBase() {}
 
@@ -120,6 +123,9 @@ class ELFSectionBase : public Section {
  *  abstraction of a section header entry for various file formats.
  */
 class ELFSection : public ELFSectionBase {
+public:
+  static std::string getTypeName() { return "ELFSection"; }
+
 public:
   explicit ELFSection(LDFileFormat::Kind ELFSectionKind,
                       const std::string &Name, uint32_t Flags, uint32_t EntSize,
diff --git a/include/eld/Readers/EhFrameHdrSection.h b/include/eld/Readers/EhFrameHdrSection.h
index e152e3c48..039ee5bfe 100644
--- a/include/eld/Readers/EhFrameHdrSection.h
+++ b/include/eld/Readers/EhFrameHdrSection.h
@@ -19,6 +19,9 @@ class CIEFragment;
 class EhFrameHdrFragment;
 
 class EhFrameHdrSection : public ELFSection {
+public:
+  static std::string getTypeName() { return "EhFrameHdrSection"; }
+
 public:
   EhFrameHdrSection(std::string Name, uint32_t pType, uint32_t pFlag,
                     uint32_t entSize, uint64_t pSize);
diff --git a/include/eld/Readers/EhFrameSection.h b/include/eld/Readers/EhFrameSection.h
index d50ba07cd..4ba763e3e 100644
--- a/include/eld/Readers/EhFrameSection.h
+++ b/include/eld/Readers/EhFrameSection.h
@@ -24,6 +24,9 @@ class CIEFragment;
 class EhFramePiece;
 
 class EhFrameSection : public ELFSection {
+public:
+  static std::string getTypeName() { return "EhFrameSection"; }
+
 public:
   EhFrameSection(std::string Name, DiagnosticEngine *diagEngine, uint32_t pType,
                  uint32_t pFlag, uint32_t entSize, uint64_t pSize);
diff --git a/include/eld/Readers/ObjectReader.h b/include/eld/Readers/ObjectReader.h
index 3ed24d901..d89d82147 100644
--- a/include/eld/Readers/ObjectReader.h
+++ b/include/eld/Readers/ObjectReader.h
@@ -21,12 +21,18 @@ class InputFile;
  *  formats.
  */
 class ObjectReader {
+public:
+  static std::string getTypeName() { return "ObjectReader"; }
+
 protected:
   ObjectReader() {}
 
 public:
   // Group Signature Info.
   class GroupSignatureInfo {
+  public:
+    static std::string getTypeName() { return "GroupSignatureInfo"; }
+
   public:
     GroupSignatureInfo(ResolveInfo *R, ELFSection *S)
         : m_Info(R), m_Section(S) {}
diff --git a/include/eld/Readers/Relocation.h b/include/eld/Readers/Relocation.h
index 8437938b1..2966b598b 100644
--- a/include/eld/Readers/Relocation.h
+++ b/include/eld/Readers/Relocation.h
@@ -29,6 +29,8 @@ class ELFSection;
 class ELFSegment;
 
 class Relocation {
+public:
+  static std::string getTypeName() { return "Relocation"; }
   static llvm::DenseMap<const Relocation *, FragmentRef *> m_RelocFragMap;
 
 public:
diff --git a/include/eld/Readers/Section.h b/include/eld/Readers/Section.h
index 5a4e0ff9d..632a4e449 100644
--- a/include/eld/Readers/Section.h
+++ b/include/eld/Readers/Section.h
@@ -20,6 +20,9 @@ class InputFile;
 class DiagnosticEngine;
 
 class Section {
+public:
+  static std::string getTypeName() { return "Section"; }
+
 public:
   enum Kind : uint8_t {
     Bitcode,
diff --git a/include/eld/Readers/SymDefReader.h b/include/eld/Readers/SymDefReader.h
index a1351f2e9..7a02fd851 100644
--- a/include/eld/Readers/SymDefReader.h
+++ b/include/eld/Readers/SymDefReader.h
@@ -17,6 +17,8 @@ class InputFile;
 class Module;
 
 class SymDefReader : public ObjectReader {
+public:
+  static std::string getTypeName() { return "SymDefReader"; }
 
 public:
   SymDefReader(Module &);
diff --git a/include/eld/Readers/TimingSection.h b/include/eld/Readers/TimingSection.h
index 4cf06d2d3..1da54edd1 100644
--- a/include/eld/Readers/TimingSection.h
+++ b/include/eld/Readers/TimingSection.h
@@ -20,6 +20,9 @@ class TimingSlice;
 class InputFile;
 
 class TimingSection : public ELFSection {
+public:
+  static std::string getTypeName() { return "TimingSection"; }
+
 public:
   explicit TimingSection(DiagnosticEngine *diagEngine,
                          llvm::StringRef SectionData, uint32_t sh_size,
diff --git a/include/eld/Readers/TimingSlice.h b/include/eld/Readers/TimingSlice.h
index 5afca86ab..c855e562e 100644
--- a/include/eld/Readers/TimingSlice.h
+++ b/include/eld/Readers/TimingSlice.h
@@ -18,6 +18,9 @@ class DiagnosticEngine;
 
 // Represents the data of a single module in timing section
 class TimingSlice {
+public:
+  static std::string getTypeName() { return "TimingSlice"; }
+
 public:
   explicit TimingSlice(llvm::StringRef Slice, llvm::StringRef InputFileName,
                        DiagnosticEngine *DiagEngine);
diff --git a/include/eld/Script/Assignment.h b/include/eld/Script/Assignment.h
index 63e3443ef..98b2a4c40 100644
--- a/include/eld/Script/Assignment.h
+++ b/include/eld/Script/Assignment.h
@@ -33,6 +33,9 @@ class ELFSection;
  */
 
 class Assignment : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "Assignment"; }
+
 public:
   enum Level {
     BEFORE_SECTIONS,  // Assignments before SECTIONS command
diff --git a/include/eld/Script/EnterScopeCmd.h b/include/eld/Script/EnterScopeCmd.h
index 07bcd1f59..8ad43783c 100644
--- a/include/eld/Script/EnterScopeCmd.h
+++ b/include/eld/Script/EnterScopeCmd.h
@@ -20,6 +20,9 @@ class Module;
  */
 
 class EnterScopeCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "EnterScopeCmd"; }
+
 public:
   EnterScopeCmd();
 
diff --git a/include/eld/Script/EntryCmd.h b/include/eld/Script/EntryCmd.h
index 543e6ea42..903ec835b 100644
--- a/include/eld/Script/EntryCmd.h
+++ b/include/eld/Script/EntryCmd.h
@@ -26,6 +26,9 @@ class Module;
  */
 
 class EntryCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "EntryCmd"; }
+
 public:
   EntryCmd(const std::string &PEntry);
 
diff --git a/include/eld/Script/ExcludeFiles.h b/include/eld/Script/ExcludeFiles.h
index 4fdf3c976..8dd9c927c 100644
--- a/include/eld/Script/ExcludeFiles.h
+++ b/include/eld/Script/ExcludeFiles.h
@@ -9,6 +9,7 @@
 
 #include "eld/Config/Config.h"
 #include <cstdint>
+#include <string>
 #include <vector>
 
 namespace eld {
@@ -20,8 +21,13 @@ class WildcardPattern;
  */
 
 class ExcludePattern {
+public:
+  static std::string getTypeName() { return "ExcludePattern"; }
+
 public:
   struct Spec {
+  public:
+    static std::string getTypeName() { return "Spec"; }
     Spec(WildcardPattern *A, WildcardPattern *F)
         : ArchiveLibraryNamePattern(A), FileNamePattern(F) {}
     WildcardPattern *ArchiveLibraryNamePattern;
@@ -43,6 +49,9 @@ class ExcludePattern {
 };
 
 class ExcludeFiles {
+public:
+  static std::string getTypeName() { return "ExcludeFiles"; }
+
 public:
   typedef std::vector<ExcludePattern *> ExcludeFileList;
   typedef ExcludeFileList::iterator iterator;
diff --git a/include/eld/Script/ExitScopeCmd.h b/include/eld/Script/ExitScopeCmd.h
index 0831d6f47..51a3d969d 100644
--- a/include/eld/Script/ExitScopeCmd.h
+++ b/include/eld/Script/ExitScopeCmd.h
@@ -20,6 +20,9 @@ class Module;
  */
 
 class ExitScopeCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "ExitScopeCmd"; }
+
 public:
   ExitScopeCmd();
 
diff --git a/include/eld/Script/Expression.h b/include/eld/Script/Expression.h
index af6acd30a..c428bd102 100644
--- a/include/eld/Script/Expression.h
+++ b/include/eld/Script/Expression.h
@@ -29,6 +29,9 @@ class ScriptFile;
  *  \brief This class defines the interfaces to an expression.
  */
 class Expression {
+public:
+  static std::string getTypeName() { return "Expression"; }
+
 public:
   enum Type {
     /* Operands */
@@ -314,6 +317,9 @@ class Expression {
  *  \brief This class extends an Expression to a Symbol operand.
  */
 class Symbol : public Expression {
+public:
+  static std::string getTypeName() { return "Symbol"; }
+
 public:
   Symbol(Module &Module, std::string Name);
 
@@ -338,6 +344,9 @@ class Symbol : public Expression {
  *  \brief This class extends an Expression to an Integer operand.
  */
 class Integer : public Expression {
+public:
+  static std::string getTypeName() { return "Integer"; }
+
 public:
   Integer(Module &Module, std::string Name, uint64_t Value)
       : Expression(Name, Expression::INTEGER, Module, Value),
@@ -363,6 +372,9 @@ class Integer : public Expression {
  *  \brief This class extends an Expression to an Add operator.
  */
 class Add : public Expression {
+public:
+  static std::string getTypeName() { return "Add"; }
+
 public:
   Add(Module &Module, Expression &Left, Expression &Right)
       : Expression("+", Expression::ADD, Module), LeftExpression(Left),
@@ -390,6 +402,9 @@ class Add : public Expression {
  *  \brief This class extends an Expression to a Subtraction operator.
  */
 class Subtract : public Expression {
+public:
+  static std::string getTypeName() { return "Subtract"; }
+
 public:
   Subtract(Module &Module, Expression &Left, Expression &Right)
       : Expression("-", Expression::SUBTRACT, Module), LeftExpression(Left),
@@ -417,6 +432,9 @@ class Subtract : public Expression {
  *  \brief This class extends an Expression to a Modulus operator.
  */
 class Modulo : public Expression {
+public:
+  static std::string getTypeName() { return "Modulo"; }
+
 public:
   Modulo(Module &Module, Expression &Left, Expression &Right)
       : Expression("%", Expression::MODULO, Module), LeftExpression(Left),
@@ -444,6 +462,9 @@ class Modulo : public Expression {
  *  \brief This class extends an Expression to a Multiply operator.
  */
 class Multiply : public Expression {
+public:
+  static std::string getTypeName() { return "Multiply"; }
+
 public:
   Multiply(Module &Module, Expression &Left, Expression &Right)
       : Expression("*", Expression::MULTIPLY, Module), LeftExpression(Left),
@@ -471,6 +492,9 @@ class Multiply : public Expression {
  *  \brief This class extends an Expression to a Divide operator.
  */
 class Divide : public Expression {
+public:
+  static std::string getTypeName() { return "Divide"; }
+
 public:
   Divide(Module &Module, Expression &Left, Expression &Right)
       : Expression("/", Expression::DIVIDE, Module), LeftExpression(Left),
@@ -498,6 +522,9 @@ class Divide : public Expression {
  *  \brief This class extends an Expression to a SizeOf operator.
  */
 class SizeOf : public Expression {
+public:
+  static std::string getTypeName() { return "SizeOf"; }
+
 public:
   SizeOf(Module &Module, std::string Name);
 
@@ -521,6 +548,9 @@ class SizeOf : public Expression {
  *  \brief This class extends an Expression to a SIZEOF_HEADERS keyword.
  */
 class SizeOfHeaders : public Expression {
+public:
+  static std::string getTypeName() { return "SizeOfHeaders"; }
+
 public:
   SizeOfHeaders(Module &Module, ScriptFile *S);
 
@@ -541,6 +571,9 @@ class SizeOfHeaders : public Expression {
  *  \brief This class extends an Expression to an OffsetOf operator.
  */
 class OffsetOf : public Expression {
+public:
+  static std::string getTypeName() { return "OffsetOf"; }
+
 public:
   OffsetOf(Module &Module, std::string Name)
       : Expression(Name, Expression::OFFSETOF, Module), ThisSection(nullptr) {}
@@ -568,6 +601,9 @@ class OffsetOf : public Expression {
  *  \brief This class extends an Expression to an Address operator.
  */
 class Addr : public Expression {
+public:
+  static std::string getTypeName() { return "Addr"; }
+
 public:
   Addr(Module &Module, std::string Name)
       : Expression(Name, Expression::ADDR, Module), ThisSection(nullptr) {}
@@ -592,6 +628,9 @@ class Addr : public Expression {
  *  \brief This class extends an Expression to an LoadAddress operator.
  */
 class LoadAddr : public Expression {
+public:
+  static std::string getTypeName() { return "LoadAddr"; }
+
 public:
   LoadAddr(Module &Module, std::string Name);
 
@@ -615,6 +654,9 @@ class LoadAddr : public Expression {
  *  \brief This class extends an Expression to an AlignmentOf operator.
  */
 class AlignExpr : public Expression {
+public:
+  static std::string getTypeName() { return "AlignExpr"; }
+
 public:
   AlignExpr(Module &Module, const std::string &Context, Expression &Align,
             Expression &Expr)
@@ -650,6 +692,9 @@ class AlignExpr : public Expression {
  *  \brief This class extends an Expression to an Alignment operator.
  */
 class AlignOf : public Expression {
+public:
+  static std::string getTypeName() { return "AlignOf"; }
+
 public:
   AlignOf(Module &Module, std::string Name)
       : Expression(Name, Expression::ALIGNOF, Module), ThisSection(nullptr) {}
@@ -677,6 +722,9 @@ class AlignOf : public Expression {
  *  \brief This class extends an Expression to an Absolute operator.
  */
 class Absolute : public Expression {
+public:
+  static std::string getTypeName() { return "Absolute"; }
+
 public:
   Absolute(Module &Module, Expression &Expr)
       : Expression("ABSOLUTE", Expression::ABSOLUTE, Module),
@@ -705,6 +753,9 @@ class Absolute : public Expression {
  *  \brief This class extends an Expression to a Ternary operator.
  */
 class Ternary : public Expression {
+public:
+  static std::string getTypeName() { return "Ternary"; }
+
 public:
   Ternary(Module &Module, Expression &Cond, Expression &Left, Expression &Right)
       : Expression("?", Expression::TERNARY, Module), ConditionExpression(Cond),
@@ -736,6 +787,9 @@ class Ternary : public Expression {
  *  \brief This class extends an Expression to a GreaterThan operator.
  */
 class ConditionGT : public Expression {
+public:
+  static std::string getTypeName() { return "ConditionGT"; }
+
 public:
   ConditionGT(Module &Module, Expression &Left, Expression &Right)
       : Expression(">", Expression::GT, Module), LeftExpression(Left),
@@ -763,6 +817,9 @@ class ConditionGT : public Expression {
  *  \brief This class extends an Expression to a LessThan operator.
  */
 class ConditionLT : public Expression {
+public:
+  static std::string getTypeName() { return "ConditionLT"; }
+
 public:
   ConditionLT(Module &Module, Expression &Left, Expression &Right)
       : Expression("<", Expression::LT, Module), LeftExpression(Left),
@@ -790,6 +847,9 @@ class ConditionLT : public Expression {
  *  \brief This class extends an Expression to an EqualTo operator.
  */
 class ConditionEQ : public Expression {
+public:
+  static std::string getTypeName() { return "ConditionEQ"; }
+
 public:
   ConditionEQ(Module &Module, Expression &Left, Expression &Right)
       : Expression("==", Expression::EQ, Module), LeftExpression(Left),
@@ -817,6 +877,9 @@ class ConditionEQ : public Expression {
  *  \brief This class extends an Expression to a GreaterThanEqual operator.
  */
 class ConditionGTE : public Expression {
+public:
+  static std::string getTypeName() { return "ConditionGTE"; }
+
 public:
   ConditionGTE(Module &Module, Expression &Left, Expression &Right)
       : Expression(">=", Expression::GTE, Module), LeftExpression(Left),
@@ -846,6 +909,9 @@ class ConditionGTE : public Expression {
  *  \brief This class extends an Expression to a LessThanEqual operator.
  */
 class ConditionLTE : public Expression {
+public:
+  static std::string getTypeName() { return "ConditionLTE"; }
+
 public:
   ConditionLTE(Module &Module, Expression &Left, Expression &Right)
       : Expression("<=", Expression::LTE, Module), LeftExpression(Left),
@@ -875,6 +941,9 @@ class ConditionLTE : public Expression {
  *  \brief This class extends an Expression to an NotEqualTo operator.
  */
 class ConditionNEQ : public Expression {
+public:
+  static std::string getTypeName() { return "ConditionNEQ"; }
+
 public:
   ConditionNEQ(Module &Module, Expression &Left, Expression &Right)
       : Expression("!=", Expression::NEQ, Module), LeftExpression(Left),
@@ -902,6 +971,9 @@ class ConditionNEQ : public Expression {
  *  \brief This class extends an Expression to a Complement operator.
  */
 class Complement : public Expression {
+public:
+  static std::string getTypeName() { return "Complement"; }
+
 public:
   Complement(Module &Module, Expression &Expr)
       : Expression("~", Expression::COM, Module), ExpressionToEvaluate(Expr) {}
@@ -929,6 +1001,9 @@ class Complement : public Expression {
  *  \brief This class extends an Expression to a UnaryPlus operator.
  */
 class UnaryPlus : public Expression {
+public:
+  static std::string getTypeName() { return "UnaryPlus"; }
+
 public:
   UnaryPlus(Module &Module, Expression &Expr)
       : Expression("+", Expression::UNARYMINUS, Module),
@@ -957,6 +1032,9 @@ class UnaryPlus : public Expression {
  *  \brief This class extends an Expression to a UnaryMinus operator.
  */
 class UnaryMinus : public Expression {
+public:
+  static std::string getTypeName() { return "UnaryMinus"; }
+
 public:
   UnaryMinus(Module &Module, Expression &Expr)
       : Expression("-", Expression::UNARYMINUS, Module),
@@ -985,6 +1063,9 @@ class UnaryMinus : public Expression {
  *  \brief This class extends an Expression to a UnaryNot operator.
  */
 class UnaryNot : public Expression {
+public:
+  static std::string getTypeName() { return "UnaryNot"; }
+
 public:
   UnaryNot(Module &Module, Expression &Expr)
       : Expression("!", Expression::UNARYNOT, Module),
@@ -1012,6 +1093,9 @@ class UnaryNot : public Expression {
  *  \brief This class extends an Expression to a Constant operator.
  */
 class Constant : public Expression {
+public:
+  static std::string getTypeName() { return "Constant"; }
+
 public:
   Constant(Module &Module, std::string Name, Type Type)
       : Expression(Name, Type, Module) {}
@@ -1036,6 +1120,9 @@ class Constant : public Expression {
  *  \brief This class extends an Expression to a SegmentStart operator.
  */
 class SegmentStart : public Expression {
+public:
+  static std::string getTypeName() { return "SegmentStart"; }
+
 public:
   SegmentStart(Module &Module, std::string Segment, Expression &Expr)
       : Expression("SEGMENT_START", Expression::SEGMENT_START, Module),
@@ -1067,6 +1154,9 @@ class SegmentStart : public Expression {
  *  \brief This class extends an Expression to an Assert command.
  */
 class AssertCmd : public Expression {
+public:
+  static std::string getTypeName() { return "AssertCmd"; }
+
 public:
   AssertCmd(Module &Module, std::string Msg, Expression &Expr)
       : Expression("ASSERT", Expression::ASSERT, Module),
@@ -1097,6 +1187,9 @@ class AssertCmd : public Expression {
  *  \brief This class extends an Expression to a Right Shift operator.
  */
 class RightShift : public Expression {
+public:
+  static std::string getTypeName() { return "RightShift"; }
+
 public:
   RightShift(Module &Module, Expression &Left, Expression &Right)
       : Expression(">>", Expression::BITWISE_RS, Module), LeftExpression(Left),
@@ -1126,6 +1219,9 @@ class RightShift : public Expression {
  *  \brief This class extends an Expression to a Left Shift operator.
  */
 class LeftShift : public Expression {
+public:
+  static std::string getTypeName() { return "LeftShift"; }
+
 public:
   LeftShift(Module &Module, Expression &Left, Expression &Right)
       : Expression("<<", Expression::BITWISE_LS, Module), LeftExpression(Left),
@@ -1155,6 +1251,9 @@ class LeftShift : public Expression {
  *  \brief This class extends an Expression to a Bitwise Or operator.
  */
 class BitwiseOr : public Expression {
+public:
+  static std::string getTypeName() { return "BitwiseOr"; }
+
 public:
   BitwiseOr(Module &Module, Expression &Left, Expression &Right)
       : Expression("|", Expression::BITWISE_OR, Module), LeftExpression(Left),
@@ -1182,6 +1281,9 @@ class BitwiseOr : public Expression {
  *  \brief This class extends an Expression to a Bitwise And operator.
  */
 class BitwiseAnd : public Expression {
+public:
+  static std::string getTypeName() { return "BitwiseAnd"; }
+
 public:
   BitwiseAnd(Module &Module, Expression &Left, Expression &Right)
       : Expression("&", Expression::BITWISE_AND, Module), LeftExpression(Left),
@@ -1209,6 +1311,9 @@ class BitwiseAnd : public Expression {
  *  \brief This class extends an Expression to a Bitwise Xor operator.
  */
 class BitwiseXor : public Expression {
+public:
+  static std::string getTypeName() { return "BitwiseXor"; }
+
 public:
   BitwiseXor(Module &Module, Expression &Left, Expression &Right)
       : Expression("^", Expression::BITWISE_XOR, Module), LeftExpression(Left),
@@ -1236,6 +1341,9 @@ class BitwiseXor : public Expression {
  *  \brief This class extends an Expression to a Defined operator.
  */
 class Defined : public Expression {
+public:
+  static std::string getTypeName() { return "Defined"; }
+
 public:
   Defined(Module &Module, std::string Name)
       : Expression(Name, Expression::DEFINED, Module) {}
@@ -1258,6 +1366,9 @@ class Defined : public Expression {
  *  \brief This class extends an Expression to a Data Segment Align operator.
  */
 class DataSegmentAlign : public Expression {
+public:
+  static std::string getTypeName() { return "DataSegmentAlign"; }
+
 public:
   DataSegmentAlign(Module &Module, Expression &MaxPageSize,
                    Expression &CommonPageSize)
@@ -1290,6 +1401,9 @@ class DataSegmentAlign : public Expression {
  * operator.
  */
 class DataSegmentRelRoEnd : public Expression {
+public:
+  static std::string getTypeName() { return "DataSegmentRelRoEnd"; }
+
 public:
   DataSegmentRelRoEnd(Module &Module, Expression &Expr1, Expression &Expr2)
       : Expression("DATA_SEGMENT_RELRO_END", Expression::DATA_SEGMENT_RELRO_END,
@@ -1324,6 +1438,9 @@ class DataSegmentRelRoEnd : public Expression {
  *  \brief This class extends an Expression to a Data Segment End operator.
  */
 class DataSegmentEnd : public Expression {
+public:
+  static std::string getTypeName() { return "DataSegmentEnd"; }
+
 public:
   DataSegmentEnd(Module &Module, Expression &Expr)
       : Expression("DATA_SEGMENT_END", Expression::DATA_SEGMENT_END, Module),
@@ -1353,6 +1470,9 @@ class DataSegmentEnd : public Expression {
  *  \brief This class extends an Expression to a Max operator.
  */
 class Max : public Expression {
+public:
+  static std::string getTypeName() { return "Max"; }
+
 public:
   Max(Module &Module, Expression &Left, Expression &Right)
       : Expression("MAX", Expression::MAX, Module), LeftExpression(Left),
@@ -1380,6 +1500,9 @@ class Max : public Expression {
  *  \brief This class extends an Expression to a Min operator.
  */
 class Min : public Expression {
+public:
+  static std::string getTypeName() { return "Min"; }
+
 public:
   Min(Module &Module, Expression &Left, Expression &Right)
       : Expression("MIN", Expression::MIN, Module), LeftExpression(Left),
@@ -1406,6 +1529,9 @@ class Min : public Expression {
  *  \brief This class extends an Expression to a Fill operator.
  */
 class Fill : public Expression {
+public:
+  static std::string getTypeName() { return "Fill"; }
+
 public:
   Fill(Module &Module, Expression &Expr)
       : Expression("FILL", Expression::FILL, Module),
@@ -1434,6 +1560,9 @@ class Fill : public Expression {
  *  \brief This class extends an Expression to a Log2Ceil operator.
  */
 class Log2Ceil : public Expression {
+public:
+  static std::string getTypeName() { return "Log2Ceil"; }
+
 public:
   Log2Ceil(Module &Module, Expression &Expr)
       : Expression("LOG2CEIL", Expression::LOG2CEIL, Module),
@@ -1462,6 +1591,9 @@ class Log2Ceil : public Expression {
  *  \brief This class extends an Expression to a logical operator.
  */
 class LogicalOp : public Expression {
+public:
+  static std::string getTypeName() { return "LogicalOp"; }
+
 public:
   LogicalOp(Expression::Type Type, Module &Module, Expression &Left,
             Expression &Right)
@@ -1493,6 +1625,9 @@ class LogicalOp : public Expression {
  *  capabiliites
  */
 class QueryMemory : public Expression {
+public:
+  static std::string getTypeName() { return "QueryMemory"; }
+
 public:
   QueryMemory(Expression::Type Type, Module &Module, const std::string &Name);
 
@@ -1519,6 +1654,9 @@ inline void alignAddress(uint64_t &PAddr, uint64_t AlignConstraint) {
 /// NullExpression represents an invalid expression. It is used as a sentinel
 /// expression when the linker script parser fails to parse an expression.
 class NullExpression : public Expression {
+public:
+  static std::string getTypeName() { return "NullExpression"; }
+
 public:
   NullExpression(Module &Module);
 
diff --git a/include/eld/Script/ExternCmd.h b/include/eld/Script/ExternCmd.h
index d09dcf7e9..f781a5420 100644
--- a/include/eld/Script/ExternCmd.h
+++ b/include/eld/Script/ExternCmd.h
@@ -24,6 +24,9 @@ class Module;
  */
 
 class ExternCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "ExternCmd"; }
+
 public:
   ExternCmd(StringList &PExtern);
 
diff --git a/include/eld/Script/FileToken.h b/include/eld/Script/FileToken.h
index 14ef3e307..cf9f60adf 100644
--- a/include/eld/Script/FileToken.h
+++ b/include/eld/Script/FileToken.h
@@ -25,6 +25,9 @@ namespace eld {
  */
 
 class FileToken : public InputToken {
+public:
+  static std::string getTypeName() { return "FileToken"; }
+
 public:
   explicit FileToken(const std::string &PName, bool PAsNeeded);
 
diff --git a/include/eld/Script/GroupCmd.h b/include/eld/Script/GroupCmd.h
index a6e507dce..43cdc6fd3 100644
--- a/include/eld/Script/GroupCmd.h
+++ b/include/eld/Script/GroupCmd.h
@@ -23,6 +23,9 @@ class LinkerConfig;
  */
 
 class GroupCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "GroupCmd"; }
+
 public:
   GroupCmd(const LinkerConfig &Config, StringList &PStringList,
            const Attribute &Attr, ScriptFile &PScriptFile);
diff --git a/include/eld/Script/IncludeCmd.h b/include/eld/Script/IncludeCmd.h
index 655ed206c..8a788bac0 100644
--- a/include/eld/Script/IncludeCmd.h
+++ b/include/eld/Script/IncludeCmd.h
@@ -15,6 +15,9 @@ namespace eld {
  */
 
 class IncludeCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "IncludeCmd"; }
+
 public:
   IncludeCmd(const std::string FileName, bool IsOptional);
 
diff --git a/include/eld/Script/InputCmd.h b/include/eld/Script/InputCmd.h
index 660e181ef..4862af42b 100644
--- a/include/eld/Script/InputCmd.h
+++ b/include/eld/Script/InputCmd.h
@@ -23,6 +23,9 @@ class LinkerConfig;
  */
 
 class InputCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "InputCmd"; }
+
 public:
   InputCmd(const LinkerConfig &Config, StringList &PStringList,
            const Attribute &Attr, ScriptFile &PScriptFile);
diff --git a/include/eld/Script/InputSectDesc.h b/include/eld/Script/InputSectDesc.h
index d3793512f..72c485944 100644
--- a/include/eld/Script/InputSectDesc.h
+++ b/include/eld/Script/InputSectDesc.h
@@ -30,12 +30,17 @@ class WildcardPattern;
  */
 
 class InputSectDesc : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "InputSectDesc"; }
+
 public:
   /* Special rule markers that dictate whether a list of input sections should
    * be kept that are handled by the rule */
   enum Policy { Keep, NoKeep, SpecialNoKeep, SpecialKeep, Fixed, KeepFixed };
 
   struct Spec {
+  public:
+    static std::string getTypeName() { return "Spec"; }
     void initialize() {
       WildcardFilePattern = nullptr;
       InputArchiveMember = nullptr;
diff --git a/include/eld/Script/InputToken.h b/include/eld/Script/InputToken.h
index a9e3a82d1..b2d82022f 100644
--- a/include/eld/Script/InputToken.h
+++ b/include/eld/Script/InputToken.h
@@ -22,6 +22,9 @@ namespace eld {
  */
 
 class InputToken : public StrToken {
+public:
+  static std::string getTypeName() { return "InputToken"; }
+
 public:
   enum Type { Unknown, File, NameSpec };
 
diff --git a/include/eld/Script/MemoryCmd.h b/include/eld/Script/MemoryCmd.h
index 447f2af12..3ca77dae7 100644
--- a/include/eld/Script/MemoryCmd.h
+++ b/include/eld/Script/MemoryCmd.h
@@ -23,6 +23,9 @@ struct MemorySpec;
  */
 
 class MemoryCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "MemoryCmd"; }
+
 public:
   MemoryCmd();
 
diff --git a/include/eld/Script/MemoryDesc.h b/include/eld/Script/MemoryDesc.h
index 1ce5c6a89..36c4d7b08 100644
--- a/include/eld/Script/MemoryDesc.h
+++ b/include/eld/Script/MemoryDesc.h
@@ -19,6 +19,8 @@ namespace eld {
  */
 
 struct MemorySpec {
+public:
+  static std::string getTypeName() { return "MemorySpec"; }
 
   MemorySpec(const StrToken *Name, const StrToken *Attributes,
              Expression *Origin, Expression *Length)
@@ -58,6 +60,9 @@ struct MemorySpec {
  */
 
 class MemoryDesc : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "MemoryDesc"; }
+
 public:
   MemoryDesc(const MemorySpec &PSpec);
 
diff --git a/include/eld/Script/NameSpec.h b/include/eld/Script/NameSpec.h
index 357439f7a..abbd63ae5 100644
--- a/include/eld/Script/NameSpec.h
+++ b/include/eld/Script/NameSpec.h
@@ -25,6 +25,9 @@ namespace eld {
  */
 
 class NameSpec : public InputToken {
+public:
+  static std::string getTypeName() { return "NameSpec"; }
+
 public:
   explicit NameSpec(const std::string &PName, bool PAsNeeded);
 
diff --git a/include/eld/Script/NoCrossRefsCmd.h b/include/eld/Script/NoCrossRefsCmd.h
index 25ef6f69d..df356336a 100644
--- a/include/eld/Script/NoCrossRefsCmd.h
+++ b/include/eld/Script/NoCrossRefsCmd.h
@@ -20,6 +20,9 @@ class Module;
  */
 
 class NoCrossRefsCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "NoCrossRefsCmd"; }
+
 public:
   NoCrossRefsCmd(StringList &PExtern, size_t PId);
 
diff --git a/include/eld/Script/OutputArchCmd.h b/include/eld/Script/OutputArchCmd.h
index 124a108e8..55133820c 100644
--- a/include/eld/Script/OutputArchCmd.h
+++ b/include/eld/Script/OutputArchCmd.h
@@ -19,6 +19,9 @@ class Module;
  */
 
 class OutputArchCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "OutputArchCmd"; }
+
 public:
   OutputArchCmd(const std::string &PArch);
 
diff --git a/include/eld/Script/OutputCmd.h b/include/eld/Script/OutputCmd.h
index 45bc03e07..00013a420 100644
--- a/include/eld/Script/OutputCmd.h
+++ b/include/eld/Script/OutputCmd.h
@@ -19,6 +19,9 @@ class Module;
  */
 
 class OutputCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "OutputCmd"; }
+
 public:
   OutputCmd(const std::string &POutputFile);
 
diff --git a/include/eld/Script/OutputFormatCmd.h b/include/eld/Script/OutputFormatCmd.h
index 4c596b1ae..e889e3c7c 100644
--- a/include/eld/Script/OutputFormatCmd.h
+++ b/include/eld/Script/OutputFormatCmd.h
@@ -26,6 +26,9 @@ class Module;
  */
 
 class OutputFormatCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "OutputFormatCmd"; }
+
 public:
   typedef std::vector<std::string> FormatList;
   typedef FormatList::const_iterator const_iterator;
diff --git a/include/eld/Script/OutputSectData.h b/include/eld/Script/OutputSectData.h
index 46d67985a..cd157c153 100644
--- a/include/eld/Script/OutputSectData.h
+++ b/include/eld/Script/OutputSectData.h
@@ -40,6 +40,9 @@ class OutputSectDesc;
 /// description. Linker creates the section for the explicit data when this
 /// special input section description is processed.
 class OutputSectData : public InputSectDesc {
+public:
+  static std::string getTypeName() { return "OutputSectData"; }
+
 public:
   enum OSDKind { None, Byte, Short, Long, Quad, Squad };
 
diff --git a/include/eld/Script/OutputSectDesc.h b/include/eld/Script/OutputSectDesc.h
index d9be85ec3..f6c17b3aa 100644
--- a/include/eld/Script/OutputSectDesc.h
+++ b/include/eld/Script/OutputSectDesc.h
@@ -32,6 +32,9 @@ class ScriptMemoryRegion;
  */
 
 class OutputSectDesc : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "OutputSectDesc"; }
+
 public:
   enum Type {
     LOAD, // ALLOC
@@ -58,6 +61,8 @@ class OutputSectDesc : public ScriptCommand {
   enum Constraint { NO_CONSTRAINT, ONLY_IF_RO, ONLY_IF_RW };
 
   struct Prolog {
+  public:
+    static std::string getTypeName() { return "Prolog"; }
     bool hasVMA() const { return OutputSectionVMA != nullptr; }
     const Expression &vma() const {
       assert(hasVMA());
@@ -176,6 +181,8 @@ class OutputSectDesc : public ScriptCommand {
   };
 
   struct Epilog {
+  public:
+    static std::string getTypeName() { return "Epilog"; }
     bool hasRegion() const { return OutputSectionMemoryRegion != nullptr; }
     const eld::ScriptMemoryRegion &region() const {
       assert(hasRegion());
diff --git a/include/eld/Script/PhdrDesc.h b/include/eld/Script/PhdrDesc.h
index a62679892..4f420afa7 100644
--- a/include/eld/Script/PhdrDesc.h
+++ b/include/eld/Script/PhdrDesc.h
@@ -19,6 +19,8 @@ namespace eld {
  */
 
 struct PhdrSpec {
+public:
+  static std::string getTypeName() { return "PhdrSpec"; }
 
   const std::string name() const { return Name->name(); }
 
@@ -56,6 +58,9 @@ struct PhdrSpec {
  */
 
 class PhdrDesc : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "PhdrDesc"; }
+
 public:
   PhdrDesc(const PhdrSpec &PSpec);
 
diff --git a/include/eld/Script/PhdrsCmd.h b/include/eld/Script/PhdrsCmd.h
index 113c1ea2b..ff3ab3f88 100644
--- a/include/eld/Script/PhdrsCmd.h
+++ b/include/eld/Script/PhdrsCmd.h
@@ -22,6 +22,9 @@ class PhdrDesc;
  */
 
 class PhdrsCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "PhdrsCmd"; }
+
 public:
   PhdrsCmd();
 
diff --git a/include/eld/Script/Plugin.h b/include/eld/Script/Plugin.h
index 3fb51a80a..766b696ba 100644
--- a/include/eld/Script/Plugin.h
+++ b/include/eld/Script/Plugin.h
@@ -24,6 +24,9 @@ class OutputTarWriter;
 class Module;
 
 class Plugin {
+public:
+  static std::string getTypeName() { return "Plugin"; }
+
 public:
   explicit Plugin(plugin::Plugin::Type T, std::string Name, std::string R,
                   std::string O, bool Stats, bool DefaultPlugin,
@@ -32,6 +35,8 @@ class Plugin {
   ~Plugin();
 
   struct CommandLineOptionSpec {
+  public:
+    static std::string getTypeName() { return "CommandLineOptionSpec"; }
     using OptionHandlerType =
         plugin::LinkerWrapper::CommandLineOptionHandlerType;
 
@@ -155,6 +160,9 @@ class Plugin {
   /// - A chunk that is removed must be put back into the image.
   /// - A chunk must not be added multiple times.
   class UnbalancedFragmentMoves {
+  public:
+    static std::string getTypeName() { return "UnbalancedFragmentMoves"; }
+
   public:
     using TrackingDataType = std::unordered_map<Fragment *, RuleContainer *>;
 
diff --git a/include/eld/Script/PluginCmd.h b/include/eld/Script/PluginCmd.h
index aa5555a7a..16989b3ae 100644
--- a/include/eld/Script/PluginCmd.h
+++ b/include/eld/Script/PluginCmd.h
@@ -22,6 +22,9 @@ class Plugin;
  */
 
 class PluginCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "PluginCmd"; }
+
 public:
   explicit PluginCmd(plugin::Plugin::Type T, const std::string &Name,
                      const std::string &R, const std::string &O);
diff --git a/include/eld/Script/RegionAlias.h b/include/eld/Script/RegionAlias.h
index 389fe0853..2cf98a073 100644
--- a/include/eld/Script/RegionAlias.h
+++ b/include/eld/Script/RegionAlias.h
@@ -29,6 +29,9 @@ class StrToken;
  */
 
 class RegionAlias : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "RegionAlias"; }
+
 public:
   explicit RegionAlias(const StrToken *Alias, const StrToken *Region);
 
diff --git a/include/eld/Script/ScriptAction.h b/include/eld/Script/ScriptAction.h
index c58b25804..adf79596f 100644
--- a/include/eld/Script/ScriptAction.h
+++ b/include/eld/Script/ScriptAction.h
@@ -24,6 +24,9 @@ class LinkerConfig;
 
 /// ScriptAction
 class ScriptAction : public InputFileAction {
+public:
+  static std::string getTypeName() { return "ScriptAction"; }
+
 public:
   ScriptAction(const std::string &PFileName, ScriptFile::Kind PKind,
                const LinkerConfig &PConfig, DiagnosticPrinter *Printer);
diff --git a/include/eld/Script/ScriptCommand.h b/include/eld/Script/ScriptCommand.h
index 8701164a3..2b97d45da 100644
--- a/include/eld/Script/ScriptCommand.h
+++ b/include/eld/Script/ScriptCommand.h
@@ -27,6 +27,9 @@ class InputFile;
  *  \brief This class defines the interfaces to a script command.
  */
 class ScriptCommand {
+public:
+  static std::string getTypeName() { return "ScriptCommand"; }
+
 public:
   enum Kind {
     ASSERT,
diff --git a/include/eld/Script/ScriptFile.h b/include/eld/Script/ScriptFile.h
index e9c8b0cab..1bc20a0e2 100644
--- a/include/eld/Script/ScriptFile.h
+++ b/include/eld/Script/ScriptFile.h
@@ -55,6 +55,9 @@ class ScriptSymbol;
  */
 
 class ScriptFile {
+public:
+  static std::string getTypeName() { return "ScriptFile"; }
+
 public:
   enum Kind {
     LDScript,              // -T
diff --git a/include/eld/Script/ScriptReader.h b/include/eld/Script/ScriptReader.h
index e9e07644b..df2308e20 100644
--- a/include/eld/Script/ScriptReader.h
+++ b/include/eld/Script/ScriptReader.h
@@ -26,6 +26,9 @@ class LinkerScript;
 class GNULDBackend;
 
 class ScriptReader {
+public:
+  static std::string getTypeName() { return "ScriptReader"; }
+
 public:
   ScriptReader();
 
diff --git a/include/eld/Script/ScriptSymbol.h b/include/eld/Script/ScriptSymbol.h
index 7375627ca..6b4965b41 100644
--- a/include/eld/Script/ScriptSymbol.h
+++ b/include/eld/Script/ScriptSymbol.h
@@ -26,6 +26,9 @@ class ResolveInfo;
  */
 
 class ScriptSymbol : public WildcardPattern {
+public:
+  static std::string getTypeName() { return "ScriptSymbol"; }
+
 public:
   explicit ScriptSymbol(const std::string &PString);
 
diff --git a/include/eld/Script/SearchDirCmd.h b/include/eld/Script/SearchDirCmd.h
index 49d7e634d..8135a51f8 100644
--- a/include/eld/Script/SearchDirCmd.h
+++ b/include/eld/Script/SearchDirCmd.h
@@ -28,6 +28,9 @@ class Module;
  */
 
 class SearchDirCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "SearchDirCmd"; }
+
 public:
   SearchDirCmd(const std::string &PPath);
 
diff --git a/include/eld/Script/SectionsCmd.h b/include/eld/Script/SectionsCmd.h
index d505bab25..fb3bfe66d 100644
--- a/include/eld/Script/SectionsCmd.h
+++ b/include/eld/Script/SectionsCmd.h
@@ -26,6 +26,9 @@ class Module;
  */
 
 class SectionsCmd : public ScriptCommand {
+public:
+  static std::string getTypeName() { return "SectionsCmd"; }
+
 public:
   typedef std::vector<ScriptCommand *> SectionCommands;
   typedef SectionCommands::const_iterator const_iterator;
diff --git a/include/eld/Script/StrToken.h b/include/eld/Script/StrToken.h
index a3cb5dbed..0ac01d7d2 100644
--- a/include/eld/Script/StrToken.h
+++ b/include/eld/Script/StrToken.h
@@ -23,6 +23,9 @@ namespace eld {
  */
 
 class StrToken {
+public:
+  static std::string getTypeName() { return "StrToken"; }
+
 public:
   enum Kind { Unknown, String, Input, Wildcard };
 
diff --git a/include/eld/Script/StringList.h b/include/eld/Script/StringList.h
index 54c229c82..5d5af56c1 100644
--- a/include/eld/Script/StringList.h
+++ b/include/eld/Script/StringList.h
@@ -25,6 +25,9 @@ class StrToken;
  */
 
 class StringList {
+public:
+  static std::string getTypeName() { return "StringList"; }
+
 public:
   typedef std::vector<StrToken *> Tokens;
   typedef Tokens::const_iterator const_iterator;
diff --git a/include/eld/Script/SymbolContainer.h b/include/eld/Script/SymbolContainer.h
index e17a69a8d..f985a6c3c 100644
--- a/include/eld/Script/SymbolContainer.h
+++ b/include/eld/Script/SymbolContainer.h
@@ -17,6 +17,9 @@ class ResolveInfo;
 class Input;
 
 class SymbolContainer {
+public:
+  static std::string getTypeName() { return "SymbolContainer"; }
+
 public:
   explicit SymbolContainer(StrToken &Token);
 
diff --git a/include/eld/Script/VersionScript.h b/include/eld/Script/VersionScript.h
index 3c2b8bb52..8dfcd24f0 100644
--- a/include/eld/Script/VersionScript.h
+++ b/include/eld/Script/VersionScript.h
@@ -28,6 +28,9 @@ scripts :-
 */
 
 class VersionSymbol {
+public:
+  static std::string getTypeName() { return "VersionSymbol"; }
+
 public:
   typedef enum : uint8_t { Simple, Extern } VersionSymbolKind;
 
@@ -60,6 +63,9 @@ class VersionSymbol {
 };
 
 class VersionScriptBlock {
+public:
+  static std::string getTypeName() { return "VersionScriptBlock"; }
+
 public:
   typedef enum : uint8_t {
     Local,
@@ -97,6 +103,9 @@ class VersionScriptBlock {
 };
 
 class LocalVersionScriptBlock : public VersionScriptBlock {
+public:
+  static std::string getTypeName() { return "LocalVersionScriptBlock"; }
+
 public:
   LocalVersionScriptBlock(class VersionScriptNode *N)
       : VersionScriptBlock(VersionScriptBlock::BlockKind::Local, N) {}
@@ -106,6 +115,9 @@ class LocalVersionScriptBlock : public VersionScriptBlock {
 };
 
 class GlobalVersionScriptBlock : public VersionScriptBlock {
+public:
+  static std::string getTypeName() { return "GlobalVersionScriptBlock"; }
+
 public:
   GlobalVersionScriptBlock(class VersionScriptNode *N)
       : VersionScriptBlock(VersionScriptBlock::BlockKind::Global, N) {}
@@ -115,6 +127,9 @@ class GlobalVersionScriptBlock : public VersionScriptBlock {
 };
 
 class VersionScriptNode {
+public:
+  static std::string getTypeName() { return "VersionScriptNode"; }
+
 public:
   VersionScriptNode();
 
@@ -160,6 +175,9 @@ class VersionScriptNode {
 };
 
 class VersionScript {
+public:
+  static std::string getTypeName() { return "VersionScript"; }
+
 public:
   VersionScript(InputFile *Inp);
 
diff --git a/include/eld/Script/WildcardPattern.h b/include/eld/Script/WildcardPattern.h
index 0319b97e2..6e2a683f9 100644
--- a/include/eld/Script/WildcardPattern.h
+++ b/include/eld/Script/WildcardPattern.h
@@ -32,6 +32,9 @@ class ExcludeFiles;
  */
 
 class WildcardPattern : public StrToken {
+public:
+  static std::string getTypeName() { return "WildcardPattern"; }
+
 public:
   enum SortPolicy {
     SORT_NONE,
diff --git a/include/eld/ScriptParser/ScriptLexer.h b/include/eld/ScriptParser/ScriptLexer.h
index ed37581b2..49963b02b 100644
--- a/include/eld/ScriptParser/ScriptLexer.h
+++ b/include/eld/ScriptParser/ScriptLexer.h
@@ -29,6 +29,9 @@ class ScriptFile;
 namespace v2 {
 
 class ScriptLexer {
+public:
+  static std::string getTypeName() { return "ScriptLexer"; }
+
 public:
   enum class LexState {
     Default,
@@ -130,6 +133,8 @@ class ScriptLexer {
 
 protected:
   struct Buffer {
+  public:
+    static std::string getTypeName() { return "Buffer"; }
     // The remaining content to parse and the filename.
     llvm::StringRef S, Filename;
     const char *Begin = nullptr;
diff --git a/include/eld/ScriptParser/ScriptParser.h b/include/eld/ScriptParser/ScriptParser.h
index 978bcb550..0ad482f58 100644
--- a/include/eld/ScriptParser/ScriptParser.h
+++ b/include/eld/ScriptParser/ScriptParser.h
@@ -28,6 +28,9 @@ namespace v2 {
 class ScriptLexer;
 
 class ScriptParser final : ScriptLexer {
+public:
+  static std::string getTypeName() { return "ScriptParser"; }
+
 public:
   ScriptParser(eld::LinkerConfig &Config, eld::ScriptFile &ScriptFile);
 
diff --git a/include/eld/Support/INIReader.h b/include/eld/Support/INIReader.h
index a9c650cb4..38b3525c2 100644
--- a/include/eld/Support/INIReader.h
+++ b/include/eld/Support/INIReader.h
@@ -22,6 +22,9 @@ namespace eld {
 /// \class INIReaderSection
 /// \brief Represents a particular section within an ini file
 class INIReaderSection {
+public:
+  static std::string getTypeName() { return "INIReaderSection"; }
+
 public:
   INIReaderSection(std::string SectionName) : sectionName(SectionName) {}
   ~INIReaderSection() = default;
@@ -55,6 +58,9 @@ class INIReaderSection {
 /// \class INIReader`
 /// \brief An ini file reader
 class INIReader {
+public:
+  static std::string getTypeName() { return "INIReader"; }
+
 public:
   enum Kind {
     Comment,
diff --git a/include/eld/Support/INIWriter.h b/include/eld/Support/INIWriter.h
index 8c7b61581..066579ace 100644
--- a/include/eld/Support/INIWriter.h
+++ b/include/eld/Support/INIWriter.h
@@ -20,6 +20,9 @@ namespace eld {
 /// \class INISection
 /// \brief Represents a particular section within an ini file
 class INISection {
+public:
+  static std::string getTypeName() { return "INISection"; }
+
 public:
   INISection() = default;
 
@@ -48,6 +51,9 @@ class INISection {
 /// \class INIWriter
 /// \brief ini file writer
 class INIWriter {
+public:
+  static std::string getTypeName() { return "INIWriter"; }
+
 public:
   INIWriter() = default;
 
diff --git a/include/eld/Support/MappingFile.h b/include/eld/Support/MappingFile.h
index 0e1e6e459..02d513352 100644
--- a/include/eld/Support/MappingFile.h
+++ b/include/eld/Support/MappingFile.h
@@ -15,6 +15,9 @@ namespace eld {
 class InputFile;
 
 class MappingFile {
+public:
+  static std::string getTypeName() { return "MappingFile"; }
+
 public:
   enum Kind {
     ObjectFile,
diff --git a/include/eld/Support/MappingFileReader.h b/include/eld/Support/MappingFileReader.h
index 72b5a33fe..98982dcb1 100644
--- a/include/eld/Support/MappingFileReader.h
+++ b/include/eld/Support/MappingFileReader.h
@@ -17,6 +17,9 @@ namespace eld {
 /// \class MappingFileReader
 /// \brief Reads a mapping.ini file and ensures it is only read once
 class MappingFileReader {
+public:
+  static std::string getTypeName() { return "MappingFileReader"; }
+
 public:
   MappingFileReader(std::string filename) {
     reader = std::make_unique<eld::INIReader>(filename);
diff --git a/include/eld/Support/Memory.h b/include/eld/Support/Memory.h
index b6ab833d4..a34953523 100644
--- a/include/eld/Support/Memory.h
+++ b/include/eld/Support/Memory.h
@@ -30,36 +30,143 @@
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/StringSaver.h"
+#include "llvm/Support/raw_ostream.h"
+#include <atomic>
+#include <cstring> // For strstr, etc.
+#include <string>
+#include <string_view>
+#include <type_traits>
 #include <vector>
 
 namespace eld {
 
-// Use this arena if your object doesn't have a destructor.
 extern llvm::BumpPtrAllocator BAlloc;
 extern llvm::StringSaver Saver;
+
 void freeArena();
 
-// These two classes are hack to keep track of all
-// SpecificBumpPtrAllocator instances.
 struct SpecificAllocBase {
   SpecificAllocBase() { Instances.push_back(this); }
   virtual ~SpecificAllocBase() = default;
+
   virtual void reset() = 0;
+  virtual const char *typeName() const = 0;
+  virtual size_t sizeOfT() const = 0;
+  virtual size_t count() const = 0;
+  virtual size_t totalBytes() const = 0;
+  virtual void report(llvm::raw_ostream &OS) const = 0;
+
   static std::vector<SpecificAllocBase *> Instances;
 };
 
+// Detect presence of static T::getTypeName()
+template <typename T, typename = void>
+struct HasGetTypeName : std::false_type {};
+
+template <typename T>
+struct HasGetTypeName<T, std::void_t<decltype(T::getTypeName())>>
+    : std::true_type {};
+
+// --- Internal detail for getting type names without RTTI ---
+namespace detail {
+
+// Fallback: Parse type name from compiler-specific function signature macro
+template <typename T> std::string parseTypeNameFromSignature() {
+#if defined(__clang__) || defined(__GNUC__)
+  const char *signature = __PRETTY_FUNCTION__;
+  const char *start = strstr(signature, "T = ");
+  if (!start)
+    return "parsing_failed";
+  start += 4; // Move past "T = "
+  const char *end = strchr(start, ']');
+  if (!end)
+    return "parsing_failed";
+  return std::string(start, end - start);
+#elif defined(_MSC_VER)
+  const char *signature = __FUNCSIG__;
+  const char *start = strstr(signature, "parseTypeNameFromSignature<");
+  if (!start)
+    return "parsing_failed";
+  start += strlen("parseTypeNameFromSignature<");
+
+  // MSVC might add "class ", "struct ", etc.
+  if (strncmp(start, "class ", 6) == 0)
+    start += 6;
+  else if (strncmp(start, "struct ", 7) == 0)
+    start += 7;
+
+  // Find the matching '>' at the end
+  const char *end = strrchr(start, '>');
+  if (!end)
+    return "parsing_failed";
+
+  return std::string(start, end - start);
+#else
+  return "unsupported_compiler";
+#endif
+}
+
+// Resolve type name: prefer user-defined, then fallback to macro parsing
+template <typename T> std::string resolveTypeName() {
+  if constexpr (HasGetTypeName<T>::value) {
+    return T::getTypeName();
+  } else {
+    // Priority 2: Fallback to parsing compiler macros
+    return parseTypeNameFromSignature<T>();
+  }
+}
+
+} // namespace detail
+
 template <class T> struct SpecificAlloc : public SpecificAllocBase {
-  void reset() override { Alloc.DestroyAll(); }
+  // The constructor now uses the robust resolveTypeName helper
+  SpecificAlloc() : TypeName(detail::resolveTypeName<T>()) {}
+
+  void reset() override {
+    Alloc.DestroyAll();
+    Cnt.store(0, std::memory_order_relaxed);
+  }
+
+  void onAllocate() { Cnt.fetch_add(1, std::memory_order_relaxed); }
+
+  const char *typeName() const override { return TypeName.c_str(); }
+  size_t sizeOfT() const override { return sizeof(T); }
+  size_t count() const override { return Cnt.load(std::memory_order_relaxed); }
+  size_t totalBytes() const override { return count() * sizeof(T); }
+
+  void report(llvm::raw_ostream &OS) const override {
+    OS << "  - " << typeName() << ": count=" << count()
+       << ", sizeof(T)=" << sizeOfT() << "B"
+       << ", total=" << totalBytes() << "B\n";
+  }
+
   llvm::SpecificBumpPtrAllocator<T> Alloc;
+  std::string TypeName;
+  std::atomic<size_t> Cnt{0};
+};
+
+template <typename T> struct ArenaForType {
+  static SpecificAlloc<T> &getAlloc() {
+    static SpecificAlloc<T> Alloc;
+    return Alloc;
+  }
+
+  template <typename... U> static T *create(U &&...Args) {
+    auto &Alloc = getAlloc();
+    T *P = new (Alloc.Alloc.Allocate()) T(std::forward<U>(Args)...);
+    Alloc.onAllocate();
+    return P;
+  }
 };
 
-// Use this arena if your object has a destructor.
-// Your destructor will be invoked from freeArena().
 template <typename T, typename... U> T *make(U &&...Args) {
-  static SpecificAlloc<T> Alloc;
-  return new (Alloc.Alloc.Allocate()) T(std::forward<U>(Args)...);
+  return ArenaForType<T>::create(std::forward<U>(Args)...);
 }
 
+std::string formatBytes(size_t bytes);
+
+void dumpArenaReport(llvm::raw_ostream &OS);
+
 const char *getUninitBuffer(uint32_t Sz);
 
 } // namespace eld
diff --git a/include/eld/Support/MemoryArea.h b/include/eld/Support/MemoryArea.h
index f4edcaa41..f258cd99f 100644
--- a/include/eld/Support/MemoryArea.h
+++ b/include/eld/Support/MemoryArea.h
@@ -27,6 +27,9 @@ class DiagnosticEngine;
  *  \brief MemoryArea is used to manage input read-only memory space.
  */
 class MemoryArea {
+public:
+  static std::string getTypeName() { return "MemoryArea"; }
+
 public:
   // Read a Input File.
   explicit MemoryArea(llvm::StringRef pFilename);
diff --git a/include/eld/Support/OutputTarWriter.h b/include/eld/Support/OutputTarWriter.h
index a055a855e..42564505b 100644
--- a/include/eld/Support/OutputTarWriter.h
+++ b/include/eld/Support/OutputTarWriter.h
@@ -29,6 +29,9 @@ class ProgressBar;
 /// \brief OutputTarWriter uses llvm::TarWriter to create --response tarball
 /// output
 class OutputTarWriter {
+public:
+  static std::string getTypeName() { return "OutputTarWriter"; }
+
 public:
   /// Create an OutputTarWriter
   /// \param OutputPath where the tarball should be written
diff --git a/include/eld/Support/Path.h b/include/eld/Support/Path.h
index 95565c68b..f0b50e390 100644
--- a/include/eld/Support/Path.h
+++ b/include/eld/Support/Path.h
@@ -40,6 +40,9 @@ const char dot = '.';
  *   the operating system's filesystem.
  */
 class Path {
+public:
+  static std::string getTypeName() { return "Path"; }
+
 public:
   Path();
   Path(const std::string &s);
diff --git a/include/eld/Support/ProgressBar.h b/include/eld/Support/ProgressBar.h
index bddd9c723..2a01d27a6 100644
--- a/include/eld/Support/ProgressBar.h
+++ b/include/eld/Support/ProgressBar.h
@@ -13,6 +13,9 @@
 
 namespace eld {
 class ProgressBar {
+public:
+  static std::string getTypeName() { return "ProgressBar"; }
+
 private:
   uint32_t ticks = 0;
   uint32_t total_ticks;
diff --git a/include/eld/Support/RegisterTimer.h b/include/eld/Support/RegisterTimer.h
index cde523fa0..9209484e1 100644
--- a/include/eld/Support/RegisterTimer.h
+++ b/include/eld/Support/RegisterTimer.h
@@ -14,6 +14,8 @@ namespace eld {
 class Input;
 
 class RegisterTimer : public llvm::NamedRegionTimer {
+public:
+  static std::string getTypeName() { return "RegisterTimer"; }
 
 public:
   // Params: Name -> Stats Description, Group -> Name of Sub-section in Linker
@@ -26,6 +28,9 @@ class RegisterTimer : public llvm::NamedRegionTimer {
 };
 
 class Timer {
+public:
+  static std::string getTypeName() { return "Timer"; }
+
 public:
   // Generic timer.
   Timer(std::string Name, std::string Description = "", bool Enable = true);
diff --git a/include/eld/Support/Target.h b/include/eld/Support/Target.h
index 13b0ce3f8..fb30e58d3 100644
--- a/include/eld/Support/Target.h
+++ b/include/eld/Support/Target.h
@@ -27,6 +27,8 @@ class GNULDBackend;
  *  \brief Target collects target specific information
  */
 struct Target {
+public:
+  static std::string getTypeName() { return "Target"; }
   typedef bool (*EmulationFnTy)(LinkerScript &, LinkerConfig &);
 
   typedef GNULDBackend *(*GNULDBackendCtorTy)(Module &);
diff --git a/include/eld/Support/TargetRegistry.h b/include/eld/Support/TargetRegistry.h
index 6a68c417c..6ff2034cb 100644
--- a/include/eld/Support/TargetRegistry.h
+++ b/include/eld/Support/TargetRegistry.h
@@ -22,6 +22,9 @@
 namespace eld {
 
 class TargetRegistry {
+public:
+  static std::string getTypeName() { return "TargetRegistry"; }
+
 private:
   static std::vector<eld::Target *> TargetList;
 
@@ -56,6 +59,9 @@ class TargetRegistry {
 };
 
 struct RegisterTarget {
+public:
+  static std::string getTypeName() { return "RegisterTarget"; }
+
 public:
   RegisterTarget(eld::Target &pTarget, llvm::StringRef Name, uint16_t Machine,
                  bool is64bit = false) {
diff --git a/include/eld/SymbolResolver/IRBuilder.h b/include/eld/SymbolResolver/IRBuilder.h
index f19d163b1..0c53810fb 100644
--- a/include/eld/SymbolResolver/IRBuilder.h
+++ b/include/eld/SymbolResolver/IRBuilder.h
@@ -36,6 +36,9 @@ class InputFile;
 class LayoutInfo;
 
 class IRBuilder {
+public:
+  static std::string getTypeName() { return "IRBuilder"; }
+
 public:
   enum ObjectFormat { ELF, MachO, COFF };
 
diff --git a/include/eld/SymbolResolver/LDSymbol.h b/include/eld/SymbolResolver/LDSymbol.h
index 3244463a1..9ed452e3a 100644
--- a/include/eld/SymbolResolver/LDSymbol.h
+++ b/include/eld/SymbolResolver/LDSymbol.h
@@ -23,6 +23,9 @@ class Input;
 class ELFSection;
 
 class LDSymbol {
+public:
+  static std::string getTypeName() { return "LDSymbol"; }
+
 public:
   // FIXME: use SizeTrait<32> or SizeTrait<64> instead of big type
   typedef ResolveInfo::SizeType SizeType;
diff --git a/include/eld/SymbolResolver/NamePool.h b/include/eld/SymbolResolver/NamePool.h
index 4240940a0..0d3061a87 100644
--- a/include/eld/SymbolResolver/NamePool.h
+++ b/include/eld/SymbolResolver/NamePool.h
@@ -41,6 +41,9 @@ class Input;
  *
  */
 class NamePool {
+public:
+  static std::string getTypeName() { return "NamePool"; }
+
 public:
   explicit NamePool(eld::LinkerConfig &Config, PluginManager &Pm);
 
diff --git a/include/eld/SymbolResolver/ResolveInfo.h b/include/eld/SymbolResolver/ResolveInfo.h
index f87bf6f15..29d7b4e3b 100644
--- a/include/eld/SymbolResolver/ResolveInfo.h
+++ b/include/eld/SymbolResolver/ResolveInfo.h
@@ -42,6 +42,9 @@ class LinkerConfig;
  *
  */
 class ResolveInfo {
+public:
+  static std::string getTypeName() { return "ResolveInfo"; }
+
 public:
   typedef uint32_t SizeType;
 
diff --git a/include/eld/SymbolResolver/Resolver.h b/include/eld/SymbolResolver/Resolver.h
index de63cb2f3..e8c61b0cb 100644
--- a/include/eld/SymbolResolver/Resolver.h
+++ b/include/eld/SymbolResolver/Resolver.h
@@ -32,6 +32,9 @@ class LinkerConfig;
  *  a shared object.
  */
 class Resolver {
+public:
+  static std::string getTypeName() { return "Resolver"; }
+
 public:
   enum Action { Success, Warning, Abort, LastAction };
 
@@ -42,6 +45,8 @@ class Resolver {
    *   - overriden, if true, the info is being overriden.
    */
   struct Result {
+  public:
+    static std::string getTypeName() { return "Result"; }
     ResolveInfo *Info;
     bool Existent;
     bool Overriden;
diff --git a/include/eld/SymbolResolver/StaticResolver.h b/include/eld/SymbolResolver/StaticResolver.h
index 21172d5d7..77eef095e 100644
--- a/include/eld/SymbolResolver/StaticResolver.h
+++ b/include/eld/SymbolResolver/StaticResolver.h
@@ -26,6 +26,9 @@ class LinkerConfig;
 /** \class StaticResolver
  */
 class StaticResolver : public Resolver {
+public:
+  static std::string getTypeName() { return "StaticResolver"; }
+
 public:
   enum LinkAction {
     FAIL,   /* abort.  */
diff --git a/include/eld/SymbolResolver/SymbolInfo.h b/include/eld/SymbolResolver/SymbolInfo.h
index 9f0ef8a3d..f52570b42 100644
--- a/include/eld/SymbolResolver/SymbolInfo.h
+++ b/include/eld/SymbolResolver/SymbolInfo.h
@@ -21,6 +21,9 @@ namespace eld {
 /// - Symbol section index kind
 /// - Input file
 class SymbolInfo {
+public:
+  static std::string getTypeName() { return "SymbolInfo"; }
+
 public:
   SymbolInfo() = default;
   SymbolInfo(const InputFile *InputFile, size_t Size,
@@ -71,6 +74,8 @@ class SymbolInfo {
 
 private:
   struct SymbolInfoBitField {
+  public:
+    static std::string getTypeName() { return "SymbolInfoBitField"; }
     SymbolInfoBitField()
         : SymBinding(0), SymType(0), SymVisibility(0), SymSectIndexKind(0),
           IsBitcode(0) {}
diff --git a/include/eld/SymbolResolver/SymbolResolutionInfo.h b/include/eld/SymbolResolver/SymbolResolutionInfo.h
index d9b50f7aa..ef4392639 100644
--- a/include/eld/SymbolResolver/SymbolResolutionInfo.h
+++ b/include/eld/SymbolResolver/SymbolResolutionInfo.h
@@ -22,6 +22,9 @@ class Plugin;
 
 /// Stores information required for reporting symbol resolution.
 class SymbolResolutionInfo {
+public:
+  static std::string getTypeName() { return "SymbolResolutionInfo"; }
+
 public:
   SymbolResolutionInfo() {}
   using CandidatesType = std::vector<const LDSymbol *>;
diff --git a/include/eld/Target/ARMEXIDXSection.h b/include/eld/Target/ARMEXIDXSection.h
index 52ca86fd0..b0c567545 100644
--- a/include/eld/Target/ARMEXIDXSection.h
+++ b/include/eld/Target/ARMEXIDXSection.h
@@ -16,11 +16,15 @@ class DiagnosticEngine;
 class RegionFragment;
 
 struct EXIDXEntry {
+public:
+  static std::string getTypeName() { return "EXIDXEntry"; }
   uint32_t InputOffset = -1;
   Fragment *Fragment = nullptr;
 };
 
 class ARMEXIDXSection : public ELFSection {
+public:
+  static std::string getTypeName() { return "ARMEXIDXSection"; }
   llvm::SmallVector<EXIDXEntry, 0> Entries;
 
 public:
diff --git a/include/eld/Target/ELFDynamic.h b/include/eld/Target/ELFDynamic.h
index bf7663dc1..bd6ea91ed 100644
--- a/include/eld/Target/ELFDynamic.h
+++ b/include/eld/Target/ELFDynamic.h
@@ -38,6 +38,9 @@ namespace elf_dynamic {
  *  section
  */
 class EntryIF {
+public:
+  static std::string getTypeName() { return "EntryIF"; }
+
 protected:
   EntryIF();
 
@@ -124,6 +127,9 @@ template <> class Entry<64, true> : public EntryIF {
  *  files.
  */
 class ELFDynamic {
+public:
+  static std::string getTypeName() { return "ELFDynamic"; }
+
 public:
   typedef std::vector<elf_dynamic::EntryIF *> EntryListType;
   typedef EntryListType::iterator iterator;
diff --git a/include/eld/Target/ELFFileFormat.h b/include/eld/Target/ELFFileFormat.h
index 796a8fa63..d1372d400 100644
--- a/include/eld/Target/ELFFileFormat.h
+++ b/include/eld/Target/ELFFileFormat.h
@@ -18,6 +18,9 @@
 namespace eld {
 
 class ELFFileFormat : public LDFileFormat {
+public:
+  static std::string getTypeName() { return "ELFFileFormat"; }
+
 public:
   ELFFileFormat();
 
@@ -79,6 +82,8 @@ class ELFFileFormat : public LDFileFormat {
 
 private:
   struct StringTableContents {
+  public:
+    static std::string getTypeName() { return "StringTableContents"; }
     std::string Strings = std::string(1, '\0');
     std::unordered_map<std::string, std::size_t> StringOffsets;
 
diff --git a/include/eld/Target/ELFSegment.h b/include/eld/Target/ELFSegment.h
index 0aa2b3d83..dbd3c7b66 100644
--- a/include/eld/Target/ELFSegment.h
+++ b/include/eld/Target/ELFSegment.h
@@ -31,6 +31,9 @@ struct PhdrSpec;
  *  \brief decribe the program header for ELF executable or shared object
  */
 class ELFSegment {
+public:
+  static std::string getTypeName() { return "ELFSegment"; }
+
 public:
   typedef std::vector<OutputSectionEntry *> SectionList;
   typedef SectionList::iterator iterator;
diff --git a/include/eld/Target/ELFSegmentFactory.h b/include/eld/Target/ELFSegmentFactory.h
index d29ff8f9c..d152269f7 100644
--- a/include/eld/Target/ELFSegmentFactory.h
+++ b/include/eld/Target/ELFSegmentFactory.h
@@ -26,6 +26,9 @@ class ELFSection;
  *  \brief provide the interface to create and delete an ELFSegment
  */
 class ELFSegmentFactory {
+public:
+  static std::string getTypeName() { return "ELFSegmentFactory"; }
+
 public:
   typedef std::vector<ELFSegment *> Segments;
   typedef Segments::const_iterator const_iterator;
diff --git a/include/eld/Target/GNULDBackend.h b/include/eld/Target/GNULDBackend.h
index ab46d82de..72fcde613 100644
--- a/include/eld/Target/GNULDBackend.h
+++ b/include/eld/Target/GNULDBackend.h
@@ -70,6 +70,9 @@ class TimingFragment;
  *  LDBackend.
  */
 class GNULDBackend {
+public:
+  static std::string getTypeName() { return "GNULDBackend"; }
+
 public:
   // Support for Fill Patterns.
   typedef struct PaddingT {
@@ -79,6 +82,8 @@ class GNULDBackend {
   } PaddingT;
 
   struct SectionOffset {
+  public:
+    static std::string getTypeName() { return "SectionOffset"; }
     ELFSection *sec = nullptr;
     uint64_t offset = 0;
   };
diff --git a/include/eld/Target/LDFileFormat.h b/include/eld/Target/LDFileFormat.h
index ef46cab13..1598567d3 100644
--- a/include/eld/Target/LDFileFormat.h
+++ b/include/eld/Target/LDFileFormat.h
@@ -23,6 +23,9 @@ class LinkerConfig;
  *  \brief LDFileFormat describes the common file formats.
  */
 class LDFileFormat {
+public:
+  static std::string getTypeName() { return "LDFileFormat"; }
+
 public:
   enum Kind : uint8_t {
     Common,
diff --git a/include/eld/Target/Relocator.h b/include/eld/Target/Relocator.h
index fa32cf102..9b8f7f7d8 100644
--- a/include/eld/Target/Relocator.h
+++ b/include/eld/Target/Relocator.h
@@ -32,6 +32,9 @@ class InputFile;
  *  \brief Relocator provides the interface of performing relocations
  */
 class Relocator {
+public:
+  static std::string getTypeName() { return "Relocator"; }
+
 public:
   typedef Relocation::Type Type;
   typedef Relocation::Address Address;
diff --git a/include/eld/Target/TargetInfo.h b/include/eld/Target/TargetInfo.h
index c0b922cbd..162d58c0e 100644
--- a/include/eld/Target/TargetInfo.h
+++ b/include/eld/Target/TargetInfo.h
@@ -28,8 +28,13 @@ class Relocation;
  *  \brief TargetInfo records ELF-dependent and target-dependnet data fields
  */
 class TargetInfo {
+public:
+  static std::string getTypeName() { return "TargetInfo"; }
+
 public:
   struct TargetRelocationType {
+  public:
+    static std::string getTypeName() { return "TargetRelocationType"; }
     Relocation::Type CopyRelocType;
   };
 
diff --git a/include/eld/Writers/ELFObjectWriter.h b/include/eld/Writers/ELFObjectWriter.h
index 1a8c33691..8e342c7a5 100644
--- a/include/eld/Writers/ELFObjectWriter.h
+++ b/include/eld/Writers/ELFObjectWriter.h
@@ -32,6 +32,9 @@ class Output;
  *
  */
 class ELFObjectWriter {
+public:
+  static std::string getTypeName() { return "ELFObjectWriter"; }
+
 public:
   ELFObjectWriter(Module &M);
 
diff --git a/include/eld/Writers/SymDefWriter.h b/include/eld/Writers/SymDefWriter.h
index d08ded936..dae6ec8c0 100644
--- a/include/eld/Writers/SymDefWriter.h
+++ b/include/eld/Writers/SymDefWriter.h
@@ -23,6 +23,9 @@ class Module;
 class LinkerConfig;
 
 class SymDefWriter {
+public:
+  static std::string getTypeName() { return "SymDefWriter"; }
+
 public:
   SymDefWriter(LinkerConfig &Config);
 
diff --git a/lib/Diagnostics/DiagnosticInfos.cpp b/lib/Diagnostics/DiagnosticInfos.cpp
index 6ea39b86e..3e06995fa 100644
--- a/lib/Diagnostics/DiagnosticInfos.cpp
+++ b/lib/Diagnostics/DiagnosticInfos.cpp
@@ -26,6 +26,9 @@ using namespace eld;
 namespace {
 
 struct DiagStaticInfo {
+public:
+  static std::string getTypeName() { return "DiagStaticInfo"; }
+
 public:
   DiagnosticEngine::DiagIDType BaseDiagID;
   llvm::StringRef DescriptionStr;
diff --git a/lib/LinkerWrapper/GnuLdDriver.cpp b/lib/LinkerWrapper/GnuLdDriver.cpp
index cc822a563..e4f1db0bd 100644
--- a/lib/LinkerWrapper/GnuLdDriver.cpp
+++ b/lib/LinkerWrapper/GnuLdDriver.cpp
@@ -129,6 +129,8 @@ GnuLdDriver *GnuLdDriver::Create(LinkerConfig &C, DriverFlavor F,
 }
 
 bool GnuLdDriver::emitStats(eld::Module &M) const {
+  if (!Config.options().printTimingStats())
+    return true;
   std::string File = Config.options().timingStatsFile();
   std::error_code error;
   llvm::raw_fd_ostream *StatsFile = nullptr;
@@ -149,6 +151,26 @@ bool GnuLdDriver::emitStats(eld::Module &M) const {
   return true;
 }
 
+bool GnuLdDriver::emitMemoryReport() const {
+  if (!Config.options().showMemoryReport())
+    return true;
+  std::string File = Config.options().getMemoryReportFile();
+  std::error_code error;
+  llvm::raw_fd_ostream *MemoryReportFile = &llvm::outs();
+  if (!File.empty()) {
+    MemoryReportFile =
+        new llvm::raw_fd_ostream(File, error, llvm::sys::fs::OF_None);
+    if (error) {
+      Config.raise(Diag::fatal_unwritable_output) << File << error.message();
+      return false;
+    }
+  }
+  eld::dumpArenaReport(*MemoryReportFile);
+  if (!File.empty())
+    delete MemoryReportFile;
+  return true;
+}
+
 bool GnuLdDriver::checkAndRaiseTraceDiagEntry(eld::Expected<void> E) const {
   if (E)
     return true;
@@ -1189,6 +1211,16 @@ bool GnuLdDriver::processOptions(llvm::opt::InputArgList &Args) {
     Config.options().setOMagic(true);
   }
 
+  // --emit-memory-report
+  if (llvm::opt::Arg *arg = Args.getLastArg(T::emit_memory_report)) {
+    Config.options().setPrintMemoryReport();
+    Config.options().setMemoryReportFile(arg->getValue());
+  }
+
+  // --print-memory-report
+  if (Args.hasArg(T::print_memory_report))
+    Config.options().setPrintMemoryReport();
+
   Config.options().setUnknownOptions(Args.getAllArgValues(T::UNKNOWN));
   return true;
 }
@@ -1714,12 +1746,16 @@ bool GnuLdDriver::doLink(llvm::opt::InputArgList &Args,
     // llvm::errs() << "destroy hook: linkStatus: " << linkStatus << "\n";
     linker.unloadPlugins();
     linkStatus &= emitStats(*ThisModule);
+    linkStatus &= emitMemoryReport();
   }
   if (Config.options().displaySummary())
     Config.getDiagEngine()->finalize();
+
   if (!linkStatus)
     Config.raise(Diag::linking_had_errors);
+
   eld::freeArena();
+
   return linkStatus;
 }
 
diff --git a/lib/Object/ObjectLinker.cpp b/lib/Object/ObjectLinker.cpp
index 129aea686..457ef017e 100644
--- a/lib/Object/ObjectLinker.cpp
+++ b/lib/Object/ObjectLinker.cpp
@@ -84,6 +84,9 @@ using namespace eld;
 namespace {
 static DiagnosticEngine *SDiagEngineForLto = nullptr;
 class PrepareDiagEngineForLTO {
+public:
+  static std::string getTypeName() { return "PrepareDiagEngineForLTO"; }
+
 public:
   PrepareDiagEngineForLTO(DiagnosticEngine *DiagEngine) {
     MMutex.lock();
@@ -1777,6 +1780,8 @@ void ObjectLinker::createRelocationSections() {
 
   // SectionName, contentPermissions, filepath
   struct SectionKey {
+  public:
+    static std::string getTypeName() { return "SectionKey"; }
     SectionKey() : Name(""), Type(-1) {}
 
     SectionKey(llvm::StringRef Name, int32_t Type) : Name(Name), Type(Type) {}
@@ -1787,6 +1792,8 @@ void ObjectLinker::createRelocationSections() {
   };
 
   struct SectionKeyInfo {
+  public:
+    static std::string getTypeName() { return "SectionKeyInfo"; }
     static SectionKey getEmptyKey() { return SectionKey(); }
     static SectionKey getTombstoneKey() { return SectionKey(); }
     static unsigned getHashValue(const SectionKey &K) {
diff --git a/lib/Script/Plugin.cpp b/lib/Script/Plugin.cpp
index cab5a7f3c..c2c142722 100644
--- a/lib/Script/Plugin.cpp
+++ b/lib/Script/Plugin.cpp
@@ -32,6 +32,8 @@
 using namespace eld;
 
 struct Running {
+public:
+  static std::string getTypeName() { return "Running"; }
   explicit Running(Plugin *P) : P(P) { P->setRunning(true); }
   ~Running() { P->setRunning(false); }
 
diff --git a/lib/Support/Memory.cpp b/lib/Support/Memory.cpp
index 49b693608..e20b5673c 100644
--- a/lib/Support/Memory.cpp
+++ b/lib/Support/Memory.cpp
@@ -13,6 +13,7 @@ using namespace eld;
 BumpPtrAllocator eld::BAlloc;
 StringSaver eld::Saver{BAlloc};
 std::vector<SpecificAllocBase *> eld::SpecificAllocBase::Instances;
+
 void eld::freeArena() {
   for (SpecificAllocBase *Alloc : llvm::reverse(SpecificAllocBase::Instances))
     Alloc->reset();
@@ -22,3 +23,44 @@ void eld::freeArena() {
 const char *eld::getUninitBuffer(uint32_t Sz) {
   return BAlloc.Allocate<char>(Sz);
 }
+
+// Format bytes using 1024-based units with a short suffix (B, KB, MB, GB, TB)
+std::string eld::formatBytes(size_t bytes) {
+  static constexpr const char *kUnits[] = {"B", "KB", "MB", "GB", "TB"};
+  double value = static_cast<double>(bytes);
+  size_t unit = 0;
+  while (value >= 1024.0 && unit < std::size(kUnits) - 1) {
+    value /= 1024.0;
+    ++unit;
+  }
+  char buf[64];
+  // Use 0 decimals for large values, 1 decimal otherwise
+  if (value >= 100.0 || unit == 0) {
+    std::snprintf(buf, sizeof(buf), "%.0f %s", value, kUnits[unit]);
+  } else {
+    std::snprintf(buf, sizeof(buf), "%.1f %s", value, kUnits[unit]);
+  }
+  return std::string(buf);
+}
+
+void eld::dumpArenaReport(llvm::raw_ostream &OS) {
+  // Copy and sort instances by total bytes (descending)
+  std::vector<SpecificAllocBase *> items = SpecificAllocBase::Instances;
+  std::sort(items.begin(), items.end(),
+            [](const SpecificAllocBase *a, const SpecificAllocBase *b) {
+              return a->totalBytes() > b->totalBytes();
+            });
+
+  size_t grandTotal = 0;
+  OS << "[eld] Arena allocation report by type (sorted by total bytes):\n";
+  for (auto *I : items) {
+    const size_t total = I->totalBytes();
+    OS << "  - " << I->typeName() << ": count=" << I->count()
+       << ", sizeof(T)=" << I->sizeOfT() << "B"
+       << ", total=" << total << "B"
+       << " (" << formatBytes(total) << ")\n";
+    grandTotal += total;
+  }
+  OS << "Grand total: " << grandTotal << "B"
+     << " (" << formatBytes(grandTotal) << ")\n";
+}
diff --git a/lib/Target/AArch64/AArch64ELFDynamic.h b/lib/Target/AArch64/AArch64ELFDynamic.h
index cace0567b..920e9eb4f 100644
--- a/lib/Target/AArch64/AArch64ELFDynamic.h
+++ b/lib/Target/AArch64/AArch64ELFDynamic.h
@@ -18,6 +18,9 @@
 namespace eld {
 
 class AArch64ELFDynamic : public ELFDynamic {
+public:
+  static std::string getTypeName() { return "AArch64ELFDynamic"; }
+
 public:
   AArch64ELFDynamic(GNULDBackend &pParent, LinkerConfig &pConfig);
   ~AArch64ELFDynamic();
diff --git a/lib/Target/AArch64/AArch64Errata843419Stub.h b/lib/Target/AArch64/AArch64Errata843419Stub.h
index 252fb1d4a..aaad5dc36 100644
--- a/lib/Target/AArch64/AArch64Errata843419Stub.h
+++ b/lib/Target/AArch64/AArch64Errata843419Stub.h
@@ -20,6 +20,9 @@ class FragmentRef;
 class IRBuilder;
 
 class AArch64Errata843419Stub : public Stub {
+public:
+  static std::string getTypeName() { return "AArch64Errata843419Stub"; }
+
 public:
   AArch64Errata843419Stub();
 
diff --git a/lib/Target/AArch64/AArch64ErrataFactory.h b/lib/Target/AArch64/AArch64ErrataFactory.h
index 5dd175f9d..add2114a0 100644
--- a/lib/Target/AArch64/AArch64ErrataFactory.h
+++ b/lib/Target/AArch64/AArch64ErrataFactory.h
@@ -24,6 +24,9 @@ class IRBuilder;
  *
  */
 class AArch64ErrataFactory {
+public:
+  static std::string getTypeName() { return "AArch64ErrataFactory"; }
+
 public:
   AArch64ErrataFactory(Stub *targetStub);
 
diff --git a/lib/Target/AArch64/AArch64ErrataIslandFactory.h b/lib/Target/AArch64/AArch64ErrataIslandFactory.h
index 1e0787764..7a20de616 100644
--- a/lib/Target/AArch64/AArch64ErrataIslandFactory.h
+++ b/lib/Target/AArch64/AArch64ErrataIslandFactory.h
@@ -22,6 +22,9 @@ class Module;
  *
  */
 class AArch64ErrataIslandFactory {
+public:
+  static std::string getTypeName() { return "AArch64ErrataIslandFactory"; }
+
 public:
   AArch64ErrataIslandFactory();
 
diff --git a/lib/Target/AArch64/AArch64FarcallStub.h b/lib/Target/AArch64/AArch64FarcallStub.h
index bbc564e2f..0b707e49d 100644
--- a/lib/Target/AArch64/AArch64FarcallStub.h
+++ b/lib/Target/AArch64/AArch64FarcallStub.h
@@ -23,6 +23,9 @@ class ResolveInfo;
  *
  */
 class AArch64FarcallStub : public Stub {
+public:
+  static std::string getTypeName() { return "AArch64FarcallStub"; }
+
 public:
   AArch64FarcallStub(bool pIsOutputPIC);
 
diff --git a/lib/Target/AArch64/AArch64GOT.h b/lib/Target/AArch64/AArch64GOT.h
index a13a42d07..09a075641 100644
--- a/lib/Target/AArch64/AArch64GOT.h
+++ b/lib/Target/AArch64/AArch64GOT.h
@@ -24,6 +24,9 @@ namespace eld {
  */
 
 class AArch64GOT : public GOT {
+public:
+  static std::string getTypeName() { return "AArch64GOT"; }
+
 public:
   // Going to be used by GOTPLT0
   AArch64GOT(GOTType T, ELFSection *O, ResolveInfo *R, uint32_t Align,
@@ -73,6 +76,9 @@ class AArch64GOT : public GOT {
 };
 
 class AArch64GOTPLT0 : public AArch64GOT {
+public:
+  static std::string getTypeName() { return "AArch64GOTPLT0"; }
+
 public:
   AArch64GOTPLT0(ELFSection *O, ResolveInfo *R)
       : AArch64GOT(GOT::GOTPLT0, O, R, 8, 24), Value() {
@@ -95,6 +101,9 @@ class AArch64GOTPLT0 : public AArch64GOT {
 };
 
 class AArch64GOTPLTN : public AArch64GOT {
+public:
+  static std::string getTypeName() { return "AArch64GOTPLTN"; }
+
 public:
   AArch64GOTPLTN(ELFSection *O, ResolveInfo *R)
       : AArch64GOT(GOT::GOTPLTN, O, R, 8, 8) {}
@@ -119,6 +128,9 @@ class AArch64GOTPLTN : public AArch64GOT {
 };
 
 class AArch64TLSDESCGOT : public AArch64GOT {
+public:
+  static std::string getTypeName() { return "AArch64TLSDESCGOT"; }
+
 public:
   AArch64TLSDESCGOT(ELFSection *O, ResolveInfo *R)
       : AArch64GOT(GOT::TLS_DESC, O, R),
@@ -137,6 +149,9 @@ class AArch64TLSDESCGOT : public AArch64GOT {
 };
 
 class AArch64IEGOT : public AArch64GOT {
+public:
+  static std::string getTypeName() { return "AArch64IEGOT"; }
+
 public:
   AArch64IEGOT(ELFSection *O, ResolveInfo *R) : AArch64GOT(GOT::TLS_LE, O, R) {}
 
diff --git a/lib/Target/AArch64/AArch64Info.h b/lib/Target/AArch64/AArch64Info.h
index f8c0b406d..630820321 100644
--- a/lib/Target/AArch64/AArch64Info.h
+++ b/lib/Target/AArch64/AArch64Info.h
@@ -23,6 +23,9 @@ namespace eld {
 class GNULDBackend;
 
 class AArch64Info : public TargetInfo {
+public:
+  static std::string getTypeName() { return "AArch64Info"; }
+
 public:
   AArch64Info(LinkerConfig &pConfig);
 
diff --git a/lib/Target/AArch64/AArch64InsnHelpers.h b/lib/Target/AArch64/AArch64InsnHelpers.h
index 23229730d..d1bbcb0df 100644
--- a/lib/Target/AArch64/AArch64InsnHelpers.h
+++ b/lib/Target/AArch64/AArch64InsnHelpers.h
@@ -18,6 +18,9 @@
 namespace eld {
 
 class AArch64InsnHelpers {
+public:
+  static std::string getTypeName() { return "AArch64InsnHelpers"; }
+
 public:
   typedef uint32_t InsnType;
 
diff --git a/lib/Target/AArch64/AArch64LDBackend.h b/lib/Target/AArch64/AArch64LDBackend.h
index 1b14a8de3..c7856aa7b 100644
--- a/lib/Target/AArch64/AArch64LDBackend.h
+++ b/lib/Target/AArch64/AArch64LDBackend.h
@@ -33,6 +33,9 @@ class TargetInfo;
 /// AArch64GNUInfoLDBackend - linker backend of AArch64 target of GNU ELF format
 ///
 class AArch64GNUInfoLDBackend : public GNULDBackend {
+public:
+  static std::string getTypeName() { return "AArch64GNUInfoLDBackend"; }
+
 public:
   AArch64GNUInfoLDBackend(Module &pModule, TargetInfo *pInfo);
   ~AArch64GNUInfoLDBackend();
diff --git a/lib/Target/AArch64/AArch64LinuxInfo.h b/lib/Target/AArch64/AArch64LinuxInfo.h
index 0a0fb6fec..41090a7e9 100644
--- a/lib/Target/AArch64/AArch64LinuxInfo.h
+++ b/lib/Target/AArch64/AArch64LinuxInfo.h
@@ -19,6 +19,9 @@
 namespace eld {
 
 class AArch64LinuxInfo : public AArch64Info {
+public:
+  static std::string getTypeName() { return "AArch64LinuxInfo"; }
+
 public:
   AArch64LinuxInfo(LinkerConfig &config) : AArch64Info(config) {}
 
diff --git a/lib/Target/AArch64/AArch64NoteGNUPropertyFragment.h b/lib/Target/AArch64/AArch64NoteGNUPropertyFragment.h
index 632f7c5a3..1cc673292 100644
--- a/lib/Target/AArch64/AArch64NoteGNUPropertyFragment.h
+++ b/lib/Target/AArch64/AArch64NoteGNUPropertyFragment.h
@@ -20,6 +20,9 @@ class LinkerConfig;
 class GNULDBackend;
 
 class AArch64NoteGNUPropertyFragment : public TargetFragment {
+public:
+  static std::string getTypeName() { return "AArch64NoteGNUPropertyFragment"; }
+
 public:
   AArch64NoteGNUPropertyFragment(ELFSection *O);
 
diff --git a/lib/Target/AArch64/AArch64PLT.h b/lib/Target/AArch64/AArch64PLT.h
index 888dbcc03..04b84e8ea 100644
--- a/lib/Target/AArch64/AArch64PLT.h
+++ b/lib/Target/AArch64/AArch64PLT.h
@@ -46,6 +46,9 @@ class AArch64GOT;
 class IRBuilder;
 
 class AArch64PLT : public PLT {
+public:
+  static std::string getTypeName() { return "AArch64PLT"; }
+
 public:
   AArch64PLT(PLT::PLTType T, eld::IRBuilder &I, AArch64GOT *G, ELFSection *P,
              ResolveInfo *R, uint32_t Align, uint32_t Size)
@@ -60,6 +63,9 @@ class AArch64PLT : public PLT {
 };
 
 class AArch64PLT0 : public AArch64PLT {
+public:
+  static std::string getTypeName() { return "AArch64PLT0"; }
+
 public:
   AArch64PLT0(AArch64GOT *G, eld::IRBuilder &I, ELFSection *P, ResolveInfo *R,
               uint32_t Align, uint32_t Size)
@@ -76,6 +82,9 @@ class AArch64PLT0 : public AArch64PLT {
 };
 
 class AArch64PLTN : public AArch64PLT {
+public:
+  static std::string getTypeName() { return "AArch64PLTN"; }
+
 public:
   AArch64PLTN(AArch64GOT *G, eld::IRBuilder &I, ELFSection *P, ResolveInfo *R,
               uint32_t Align, uint32_t Size)
diff --git a/lib/Target/AArch64/AArch64Relocator.cpp b/lib/Target/AArch64/AArch64Relocator.cpp
index eb57d2a55..fb3aca094 100644
--- a/lib/Target/AArch64/AArch64Relocator.cpp
+++ b/lib/Target/AArch64/AArch64Relocator.cpp
@@ -104,6 +104,9 @@ typedef Relocator::Result (*ApplyFunctionType)(Relocation &pReloc,
 
 // the table entry of applying functions
 class ApplyFunctionEntry {
+public:
+  static std::string getTypeName() { return "ApplyFunctionEntry"; }
+
 public:
   ApplyFunctionEntry() {}
   ApplyFunctionEntry(ApplyFunctionType pFunc, const char *pName,
diff --git a/lib/Target/AArch64/AArch64Relocator.h b/lib/Target/AArch64/AArch64Relocator.h
index 17fc2c9a6..6f2141a92 100644
--- a/lib/Target/AArch64/AArch64Relocator.h
+++ b/lib/Target/AArch64/AArch64Relocator.h
@@ -44,6 +44,9 @@ enum {
  *
  */
 class AArch64Relocator : public Relocator {
+public:
+  static std::string getTypeName() { return "AArch64Relocator"; }
+
 public:
   AArch64Relocator(AArch64GNUInfoLDBackend &pParent, LinkerConfig &pConfig,
                    Module &pModule);
diff --git a/lib/Target/ARM/ARMAttributeFragment.h b/lib/Target/ARM/ARMAttributeFragment.h
index 461ffe95d..6fb9af2ec 100644
--- a/lib/Target/ARM/ARMAttributeFragment.h
+++ b/lib/Target/ARM/ARMAttributeFragment.h
@@ -35,6 +35,8 @@ class Module;
 enum class ARMVFPArgKind { Default, Base, VFP, ToolChain };
 
 struct OutputARMAttributes {
+public:
+  static std::string getTypeName() { return "OutputARMAttributes"; }
   bool armHasBlx = false;
   bool armJ1J2BranchEncoding = false;
   bool armHasMovtMovw = false;
@@ -47,6 +49,9 @@ struct OutputARMAttributes {
 };
 
 class ARMAttributeFragment : public TargetFragment {
+public:
+  static std::string getTypeName() { return "ARMAttributeFragment"; }
+
 public:
   ARMAttributeFragment(ELFSection *O);
 
diff --git a/lib/Target/ARM/ARMELFDynamic.h b/lib/Target/ARM/ARMELFDynamic.h
index 45d631648..b1a2173c1 100644
--- a/lib/Target/ARM/ARMELFDynamic.h
+++ b/lib/Target/ARM/ARMELFDynamic.h
@@ -21,6 +21,9 @@
 namespace eld {
 
 class ARMELFDynamic : public ELFDynamic {
+public:
+  static std::string getTypeName() { return "ARMELFDynamic"; }
+
 public:
   ARMELFDynamic(GNULDBackend &pParent, LinkerConfig &pConfig);
   ~ARMELFDynamic();
diff --git a/lib/Target/ARM/ARMGOT.h b/lib/Target/ARM/ARMGOT.h
index d2edc86f2..91311b7f2 100644
--- a/lib/Target/ARM/ARMGOT.h
+++ b/lib/Target/ARM/ARMGOT.h
@@ -24,6 +24,9 @@ namespace eld {
  */
 
 class ARMGOT : public GOT {
+public:
+  static std::string getTypeName() { return "ARMGOT"; }
+
 public:
   // Going to be used by GOTPLT0
   ARMGOT(GOTType T, ELFSection *O, ResolveInfo *R, uint32_t Align,
@@ -85,6 +88,9 @@ class ARMGOT : public GOT {
 };
 
 class ARMGOTPLT0 : public ARMGOT {
+public:
+  static std::string getTypeName() { return "ARMGOTPLT0"; }
+
 public:
   ARMGOTPLT0(ELFSection *O, ResolveInfo *R)
       : ARMGOT(GOT::GOTPLT0, O, R, 4, 12), Value() {
@@ -107,6 +113,9 @@ class ARMGOTPLT0 : public ARMGOT {
 };
 
 class ARMGOTPLTN : public ARMGOT {
+public:
+  static std::string getTypeName() { return "ARMGOTPLTN"; }
+
 public:
   ARMGOTPLTN(ELFSection *O, ResolveInfo *R)
       : ARMGOT(GOT::GOTPLTN, O, R, 4, 4) {}
@@ -131,6 +140,9 @@ class ARMGOTPLTN : public ARMGOT {
 };
 
 class ARMGDGOT : public ARMGOT {
+public:
+  static std::string getTypeName() { return "ARMGDGOT"; }
+
 public:
   ARMGDGOT(ELFSection *O, ResolveInfo *R)
       : ARMGOT(GOT::TLS_GD, O, R), Other(make<ARMGOT>(GOT::TLS_GD, O, R)) {}
@@ -148,6 +160,9 @@ class ARMGDGOT : public ARMGOT {
 };
 
 class ARMLDGOT : public ARMGOT {
+public:
+  static std::string getTypeName() { return "ARMLDGOT"; }
+
 public:
   ARMLDGOT(ELFSection *O, ResolveInfo *R)
       : ARMGOT(GOT::TLS_LD, O, R), Other(make<ARMGOT>(GOT::TLS_LD, O, R)) {}
@@ -165,6 +180,9 @@ class ARMLDGOT : public ARMGOT {
 };
 
 class ARMIEGOT : public ARMGOT {
+public:
+  static std::string getTypeName() { return "ARMIEGOT"; }
+
 public:
   ARMIEGOT(ELFSection *O, ResolveInfo *R) : ARMGOT(GOT::TLS_LE, O, R) {}
 
diff --git a/lib/Target/ARM/ARMInfo.h b/lib/Target/ARM/ARMInfo.h
index d9644a784..848a7693a 100644
--- a/lib/Target/ARM/ARMInfo.h
+++ b/lib/Target/ARM/ARMInfo.h
@@ -20,6 +20,9 @@
 namespace eld {
 
 class ARMInfo : public TargetInfo {
+public:
+  static std::string getTypeName() { return "ARMInfo"; }
+
 public:
   ARMInfo(LinkerConfig &pConfig) : TargetInfo(pConfig) {}
 
diff --git a/lib/Target/ARM/ARMLDBackend.h b/lib/Target/ARM/ARMLDBackend.h
index 37946a3ce..0df8fa212 100644
--- a/lib/Target/ARM/ARMLDBackend.h
+++ b/lib/Target/ARM/ARMLDBackend.h
@@ -35,6 +35,9 @@ class ARMAttributeFragment;
 /// ARMGNULDBackend - linker backend of ARM target of GNU ELF format
 ///
 class ARMGNULDBackend : public GNULDBackend {
+public:
+  static std::string getTypeName() { return "ARMGNULDBackend"; }
+
 public:
   // max branch offsets for ARM, THUMB, and THUMB2
   // @ref gold/arm.cc:99
diff --git a/lib/Target/ARM/ARMPLT.h b/lib/Target/ARM/ARMPLT.h
index 62c85c5b4..7aee0de46 100644
--- a/lib/Target/ARM/ARMPLT.h
+++ b/lib/Target/ARM/ARMPLT.h
@@ -48,6 +48,9 @@ class ARMGOT;
 class IRBuilder;
 
 class ARMPLT : public PLT {
+public:
+  static std::string getTypeName() { return "ARMPLT"; }
+
 public:
   ARMPLT(PLT::PLTType T, eld::IRBuilder &I, ARMGOT *G, ELFSection *P,
          ResolveInfo *R, uint32_t Align, uint32_t Size)
@@ -62,6 +65,9 @@ class ARMPLT : public PLT {
 };
 
 class ARMPLT0 : public ARMPLT {
+public:
+  static std::string getTypeName() { return "ARMPLT0"; }
+
 public:
   ARMPLT0(ARMGOT *G, eld::IRBuilder &I, ELFSection *P, ResolveInfo *R,
           uint32_t Align, uint32_t Size)
@@ -78,6 +84,9 @@ class ARMPLT0 : public ARMPLT {
 };
 
 class ARMPLTN : public ARMPLT {
+public:
+  static std::string getTypeName() { return "ARMPLTN"; }
+
 public:
   ARMPLTN(ARMGOT *G, eld::IRBuilder &I, ELFSection *P, ResolveInfo *R,
           uint32_t Align, uint32_t Size)
diff --git a/lib/Target/ARM/ARMRelocator.cpp b/lib/Target/ARM/ARMRelocator.cpp
index 31e461f5a..e39dde28d 100644
--- a/lib/Target/ARM/ARMRelocator.cpp
+++ b/lib/Target/ARM/ARMRelocator.cpp
@@ -236,6 +236,8 @@ typedef Relocator::Result (*ApplyFunctionType)(Relocation &pReloc,
 
 // the table entry of applying functions
 struct ApplyFunctionTriple {
+public:
+  static std::string getTypeName() { return "ApplyFunctionTriple"; }
   ApplyFunctionType func;
   unsigned int type;
   const char *name;
diff --git a/lib/Target/ARM/ARMRelocator.h b/lib/Target/ARM/ARMRelocator.h
index f6f51fb97..ccb196ff1 100644
--- a/lib/Target/ARM/ARMRelocator.h
+++ b/lib/Target/ARM/ARMRelocator.h
@@ -24,6 +24,9 @@ namespace eld {
  *
  */
 class ARMRelocator : public Relocator {
+public:
+  static std::string getTypeName() { return "ARMRelocator"; }
+
 public:
   ARMRelocator(ARMGNULDBackend &pParent, LinkerConfig &pConfig,
                Module &pModule);
diff --git a/lib/Target/ARM/ARMToARMStub.h b/lib/Target/ARM/ARMToARMStub.h
index bef86798c..d2c728499 100644
--- a/lib/Target/ARM/ARMToARMStub.h
+++ b/lib/Target/ARM/ARMToARMStub.h
@@ -26,6 +26,9 @@ class Module;
  *
  */
 class ARMToARMStub : public Stub {
+public:
+  static std::string getTypeName() { return "ARMToARMStub"; }
+
 public:
   ARMToARMStub(uint32_t type, ARMGNULDBackend *Target);
 
diff --git a/lib/Target/ARM/ARMToTHMStub.h b/lib/Target/ARM/ARMToTHMStub.h
index 2c0170806..046554945 100644
--- a/lib/Target/ARM/ARMToTHMStub.h
+++ b/lib/Target/ARM/ARMToTHMStub.h
@@ -24,6 +24,9 @@ class Module;
  *
  */
 class ARMToTHMStub : public Stub {
+public:
+  static std::string getTypeName() { return "ARMToTHMStub"; }
+
 public:
   ARMToTHMStub(uint32_t type, ARMGNULDBackend *Target);
 
diff --git a/lib/Target/ARM/THMToARMStub.h b/lib/Target/ARM/THMToARMStub.h
index a0047d72e..25e6b25e5 100644
--- a/lib/Target/ARM/THMToARMStub.h
+++ b/lib/Target/ARM/THMToARMStub.h
@@ -25,6 +25,9 @@ class ResolveInfo;
  *
  */
 class THMToARMStub : public Stub {
+public:
+  static std::string getTypeName() { return "THMToARMStub"; }
+
 public:
   THMToARMStub(uint32_t type, ARMGNULDBackend *Target);
 
diff --git a/lib/Target/ARM/THMToTHMStub.h b/lib/Target/ARM/THMToTHMStub.h
index 8da209407..40adef901 100644
--- a/lib/Target/ARM/THMToTHMStub.h
+++ b/lib/Target/ARM/THMToTHMStub.h
@@ -26,6 +26,9 @@ class Module;
  *
  */
 class THMToTHMStub : public Stub {
+public:
+  static std::string getTypeName() { return "THMToTHMStub"; }
+
 public:
   THMToTHMStub(uint32_t type, ARMGNULDBackend *Target);
 
diff --git a/lib/Target/Hexagon/HexagonAbsoluteStub.h b/lib/Target/Hexagon/HexagonAbsoluteStub.h
index 37a8a07f3..b1ed9c403 100644
--- a/lib/Target/Hexagon/HexagonAbsoluteStub.h
+++ b/lib/Target/Hexagon/HexagonAbsoluteStub.h
@@ -25,6 +25,9 @@ class ResolveInfo;
  *
  */
 class HexagonAbsoluteStub : public Stub {
+public:
+  static std::string getTypeName() { return "HexagonAbsoluteStub"; }
+
 public:
   HexagonAbsoluteStub(bool pIsOutputPIC);
 
diff --git a/lib/Target/Hexagon/HexagonAttributeFragment.h b/lib/Target/Hexagon/HexagonAttributeFragment.h
index 6515027d7..987ab0e3c 100644
--- a/lib/Target/Hexagon/HexagonAttributeFragment.h
+++ b/lib/Target/Hexagon/HexagonAttributeFragment.h
@@ -14,6 +14,9 @@
 namespace eld {
 class ObjectFile;
 class HexagonAttributeFragment : public TargetFragment {
+public:
+  static std::string getTypeName() { return "HexagonAttributeFragment"; }
+
 public:
   HexagonAttributeFragment(ELFSection *O);
 
diff --git a/lib/Target/Hexagon/HexagonELFDynamic.h b/lib/Target/Hexagon/HexagonELFDynamic.h
index f67029e74..140609362 100644
--- a/lib/Target/Hexagon/HexagonELFDynamic.h
+++ b/lib/Target/Hexagon/HexagonELFDynamic.h
@@ -18,6 +18,9 @@ enum {
 };
 
 class HexagonELFDynamic : public ELFDynamic {
+public:
+  static std::string getTypeName() { return "HexagonELFDynamic"; }
+
 public:
   HexagonELFDynamic(GNULDBackend &pParent, LinkerConfig &pConfig);
   ~HexagonELFDynamic();
diff --git a/lib/Target/Hexagon/HexagonGOT.h b/lib/Target/Hexagon/HexagonGOT.h
index 6a6df8240..c65d2181b 100644
--- a/lib/Target/Hexagon/HexagonGOT.h
+++ b/lib/Target/Hexagon/HexagonGOT.h
@@ -18,6 +18,9 @@ namespace eld {
  */
 
 class HexagonGOT : public GOT {
+public:
+  static std::string getTypeName() { return "HexagonGOT"; }
+
 public:
   // Going to be used by GOTPLT0
   HexagonGOT(GOTType T, ELFSection *O, ResolveInfo *R, uint32_t Align,
@@ -67,6 +70,9 @@ class HexagonGOT : public GOT {
 };
 
 class HexagonGOTPLT0 : public HexagonGOT {
+public:
+  static std::string getTypeName() { return "HexagonGOTPLT0"; }
+
 public:
   HexagonGOTPLT0(ELFSection *O, ResolveInfo *R)
       : HexagonGOT(GOT::GOTPLT0, O, R, 4, 16) {}
@@ -86,6 +92,9 @@ class HexagonGOTPLT0 : public HexagonGOT {
 };
 
 class HexagonGOTPLTN : public HexagonGOT {
+public:
+  static std::string getTypeName() { return "HexagonGOTPLTN"; }
+
 public:
   HexagonGOTPLTN(ELFSection *O, ResolveInfo *R)
       : HexagonGOT(GOT::GOTPLTN, O, R, 4, 4) {}
@@ -98,6 +107,9 @@ class HexagonGOTPLTN : public HexagonGOT {
 };
 
 class HexagonGDGOT : public HexagonGOT {
+public:
+  static std::string getTypeName() { return "HexagonGDGOT"; }
+
 public:
   HexagonGDGOT(ELFSection *O, ResolveInfo *R)
       : HexagonGOT(GOT::TLS_GD, O, R),
@@ -116,6 +128,9 @@ class HexagonGDGOT : public HexagonGOT {
 };
 
 class HexagonLDGOT : public HexagonGOT {
+public:
+  static std::string getTypeName() { return "HexagonLDGOT"; }
+
 public:
   HexagonLDGOT(ELFSection *O, ResolveInfo *R)
       : HexagonGOT(GOT::TLS_LD, O, R),
@@ -134,6 +149,9 @@ class HexagonLDGOT : public HexagonGOT {
 };
 
 class HexagonIEGOT : public HexagonGOT {
+public:
+  static std::string getTypeName() { return "HexagonIEGOT"; }
+
 public:
   HexagonIEGOT(ELFSection *O, ResolveInfo *R) : HexagonGOT(GOT::TLS_LE, O, R) {}
 
diff --git a/lib/Target/Hexagon/HexagonInfo.h b/lib/Target/Hexagon/HexagonInfo.h
index 81896e1e4..d397c8f0d 100644
--- a/lib/Target/Hexagon/HexagonInfo.h
+++ b/lib/Target/Hexagon/HexagonInfo.h
@@ -15,6 +15,9 @@
 namespace eld {
 
 class HexagonInfo : public TargetInfo {
+public:
+  static std::string getTypeName() { return "HexagonInfo"; }
+
 public:
   // This enumeration creates a mapping in the static array for every input
   // flag.
diff --git a/lib/Target/Hexagon/HexagonLDBackend.cpp b/lib/Target/Hexagon/HexagonLDBackend.cpp
index 8c26493cd..da5be8454 100644
--- a/lib/Target/Hexagon/HexagonLDBackend.cpp
+++ b/lib/Target/Hexagon/HexagonLDBackend.cpp
@@ -62,6 +62,9 @@ namespace {
 // HexagonLDBackend::allocateMemoryBlock function.
 static DiagnosticEngine *sDiagEngine = nullptr;
 class PrepareStaticDiagEngine {
+public:
+  static std::string getTypeName() { return "PrepareStaticDiagEngine"; }
+
 public:
   PrepareStaticDiagEngine(DiagnosticEngine *diagEngine) {
     m_Mutex.lock();
diff --git a/lib/Target/Hexagon/HexagonLDBackend.h b/lib/Target/Hexagon/HexagonLDBackend.h
index af7873fb1..ebe5fc973 100644
--- a/lib/Target/Hexagon/HexagonLDBackend.h
+++ b/lib/Target/Hexagon/HexagonLDBackend.h
@@ -28,6 +28,9 @@ class RegionFragmentEx;
 /// HexagonLDBackend - linker backend of Hexagon target of GNU ELF format
 ///
 class HexagonLDBackend : public GNULDBackend {
+public:
+  static std::string getTypeName() { return "HexagonLDBackend"; }
+
 public:
   HexagonLDBackend(Module &pModule, HexagonInfo *pInfo);
 
diff --git a/lib/Target/Hexagon/HexagonLinuxInfo.h b/lib/Target/Hexagon/HexagonLinuxInfo.h
index 82d490b9c..c9fc22232 100644
--- a/lib/Target/Hexagon/HexagonLinuxInfo.h
+++ b/lib/Target/Hexagon/HexagonLinuxInfo.h
@@ -13,6 +13,9 @@
 namespace eld {
 
 class HexagonLinuxInfo : public HexagonInfo {
+public:
+  static std::string getTypeName() { return "HexagonLinuxInfo"; }
+
 public:
   HexagonLinuxInfo(LinkerConfig &config) : HexagonInfo(config) {}
 
diff --git a/lib/Target/Hexagon/HexagonPLT.h b/lib/Target/Hexagon/HexagonPLT.h
index b018e925e..b1a8c5682 100644
--- a/lib/Target/Hexagon/HexagonPLT.h
+++ b/lib/Target/Hexagon/HexagonPLT.h
@@ -40,6 +40,9 @@ class HexagonGOT;
 class IRBuilder;
 
 class HexagonPLT : public PLT {
+public:
+  static std::string getTypeName() { return "HexagonPLT"; }
+
 public:
   HexagonPLT(PLT::PLTType T, eld::IRBuilder &I, HexagonGOT *G, ELFSection *P,
              ResolveInfo *R, uint32_t Align, uint32_t Size)
@@ -51,6 +54,9 @@ class HexagonPLT : public PLT {
 };
 
 class HexagonPLT0 : public HexagonPLT {
+public:
+  static std::string getTypeName() { return "HexagonPLT0"; }
+
 public:
   HexagonPLT0(HexagonGOT *G, eld::IRBuilder &I, ELFSection *P, ResolveInfo *R,
               uint32_t Align, uint32_t Size)
@@ -67,6 +73,9 @@ class HexagonPLT0 : public HexagonPLT {
 };
 
 class HexagonPLTN : public HexagonPLT {
+public:
+  static std::string getTypeName() { return "HexagonPLTN"; }
+
 public:
   HexagonPLTN(HexagonGOT *G, eld::IRBuilder &I, ELFSection *P, ResolveInfo *R,
               uint32_t Align, uint32_t Size)
diff --git a/lib/Target/Hexagon/HexagonRelocationFunctions.h b/lib/Target/Hexagon/HexagonRelocationFunctions.h
index 55126ec60..81f277b7b 100644
--- a/lib/Target/Hexagon/HexagonRelocationFunctions.h
+++ b/lib/Target/Hexagon/HexagonRelocationFunctions.h
@@ -9,6 +9,7 @@
 
 #include "HexagonLLVMExtern.h"
 #include "HexagonRelocator.h"
+#include <string>
 
 namespace eld {
 
@@ -66,6 +67,8 @@ typedef Relocator::Result (*ApplyFunctionType)(
     RelocationDescription &pRelocDesc);
 
 struct RelocationDescription {
+public:
+  static std::string getTypeName() { return "RelocationDescription"; }
   // The application function for the relocation.
   const ApplyFunctionType func;
   // The Relocation type, this is just kept for convenience when writing new
diff --git a/lib/Target/Hexagon/HexagonRelocator.h b/lib/Target/Hexagon/HexagonRelocator.h
index 59f9eb159..70fbe6806 100644
--- a/lib/Target/Hexagon/HexagonRelocator.h
+++ b/lib/Target/Hexagon/HexagonRelocator.h
@@ -26,6 +26,9 @@ class LinkerConfig;
  *
  */
 class HexagonRelocator : public Relocator {
+public:
+  static std::string getTypeName() { return "HexagonRelocator"; }
+
 public:
   HexagonRelocator(HexagonLDBackend &pParent, LinkerConfig &pConfig,
                    Module &pModule);
diff --git a/lib/Target/Hexagon/HexagonStandaloneInfo.h b/lib/Target/Hexagon/HexagonStandaloneInfo.h
index d4539381b..05e1f991b 100644
--- a/lib/Target/Hexagon/HexagonStandaloneInfo.h
+++ b/lib/Target/Hexagon/HexagonStandaloneInfo.h
@@ -15,6 +15,9 @@
 namespace eld {
 
 class HexagonStandaloneInfo : public HexagonInfo {
+public:
+  static std::string getTypeName() { return "HexagonStandaloneInfo"; }
+
 public:
   HexagonStandaloneInfo(LinkerConfig &pConfig) : HexagonInfo(pConfig) {}
 
diff --git a/lib/Target/Hexagon/HexagonTLSStub.h b/lib/Target/Hexagon/HexagonTLSStub.h
index e62078b03..4d3ae9cfd 100644
--- a/lib/Target/Hexagon/HexagonTLSStub.h
+++ b/lib/Target/Hexagon/HexagonTLSStub.h
@@ -29,6 +29,9 @@ class Module;
 // HexagonTLSStub
 //===----------------------------------------------------------------------===//
 class HexagonTLSStub : public TargetFragment {
+public:
+  static std::string getTypeName() { return "HexagonTLSStub"; }
+
 public:
   enum StubType { GD, GDtoIE, LDtoLE };
 
@@ -58,6 +61,9 @@ class HexagonTLSStub : public TargetFragment {
 };
 
 class HexagonGDStub : public HexagonTLSStub {
+public:
+  static std::string getTypeName() { return "HexagonGDStub"; }
+
 public:
   HexagonGDStub(ELFSection *O, ResolveInfo *R)
       : HexagonTLSStub(HexagonTLSStub::GD, O, R, 4, 0) {};
@@ -72,6 +78,9 @@ class HexagonGDStub : public HexagonTLSStub {
 };
 
 class HexagonGDIEStub : public HexagonTLSStub {
+public:
+  static std::string getTypeName() { return "HexagonGDIEStub"; }
+
 public:
   HexagonGDIEStub(ELFSection *O, ResolveInfo *R)
       : HexagonTLSStub(HexagonTLSStub::GDtoIE, O, R, 4,
@@ -91,6 +100,9 @@ class HexagonGDIEStub : public HexagonTLSStub {
 };
 
 class HexagonLDLEStub : public HexagonTLSStub {
+public:
+  static std::string getTypeName() { return "HexagonLDLEStub"; }
+
 public:
   HexagonLDLEStub(ELFSection *O, ResolveInfo *R)
       : HexagonTLSStub(HexagonTLSStub::LDtoLE, O, R, 4,
diff --git a/lib/Target/RISCV/RISCVAttributeFragment.h b/lib/Target/RISCV/RISCVAttributeFragment.h
index a6947814a..ec68795d6 100644
--- a/lib/Target/RISCV/RISCVAttributeFragment.h
+++ b/lib/Target/RISCV/RISCVAttributeFragment.h
@@ -27,10 +27,15 @@ class GNULDBackend;
 class LinkerConfig;
 
 class RISCVAttributeFragment : public TargetFragment {
+public:
+  static std::string getTypeName() { return "RISCVAttributeFragment"; }
+
 public:
   enum class AttributeType { Hidden, Numeric, Text, NumericAndText };
 
   struct AttributeItem {
+  public:
+    static std::string getTypeName() { return "AttributeItem"; }
     AttributeType Type;
     unsigned Tag;
     unsigned IntValue;
diff --git a/lib/Target/RISCV/RISCVELFDynamic.h b/lib/Target/RISCV/RISCVELFDynamic.h
index f35a7092f..6d13254bc 100644
--- a/lib/Target/RISCV/RISCVELFDynamic.h
+++ b/lib/Target/RISCV/RISCVELFDynamic.h
@@ -12,6 +12,9 @@
 namespace eld {
 
 class RISCVELFDynamic : public ELFDynamic {
+public:
+  static std::string getTypeName() { return "RISCVELFDynamic"; }
+
 public:
   RISCVELFDynamic(GNULDBackend &pParent, LinkerConfig &pConfig);
   ~RISCVELFDynamic();
diff --git a/lib/Target/RISCV/RISCVGOT.h b/lib/Target/RISCV/RISCVGOT.h
index d35f074be..6f8fa409f 100644
--- a/lib/Target/RISCV/RISCVGOT.h
+++ b/lib/Target/RISCV/RISCVGOT.h
@@ -18,6 +18,9 @@ namespace eld {
  */
 
 class RISCVGOT : public GOT {
+public:
+  static std::string getTypeName() { return "RISCVGOT"; }
+
 public:
   // Going to be used by GOTPLT0
   RISCVGOT(GOTType T, ELFSection *O, ResolveInfo *R, uint32_t Align,
@@ -71,6 +74,9 @@ class RISCVGOT : public GOT {
 
 template <typename T, uint32_t Align, uint32_t Size>
 class RISCVTGOT : public RISCVGOT {
+public:
+  static std::string getTypeName() { return "RISCVTGOT"; }
+
 public:
   // Going to be used by GOTPLT0
   RISCVTGOT(GOTType gotType, ELFSection *O, ResolveInfo *R)
@@ -100,6 +106,9 @@ class RISCVTGOT : public RISCVGOT {
 
 template <typename T, uint32_t Align, uint32_t Size>
 class RISCVGOTPLTN : public RISCVTGOT<T, Align, Size> {
+public:
+  static std::string getTypeName() { return "RISCVGOTPLTN"; }
+
 public:
   RISCVGOTPLTN(ELFSection *O, ResolveInfo *R)
       : RISCVTGOT<T, Align, Size>(GOT::GOTPLTN, O, R) {}
@@ -111,6 +120,9 @@ class RISCVGOTPLTN : public RISCVTGOT<T, Align, Size> {
 
 template <typename T>
 class RISCVGOTPLT0 : public RISCVTGOT<T, sizeof(T), sizeof(T) * 2> {
+public:
+  static std::string getTypeName() { return "RISCVGOTPLT0"; }
+
 public:
   RISCVGOTPLT0(ELFSection *O, ResolveInfo *R)
       : RISCVTGOT<T, sizeof(T), sizeof(T) * 2>(GOT::GOTPLT0, O, R) {}
@@ -122,6 +134,9 @@ class RISCVGOTPLT0 : public RISCVTGOT<T, sizeof(T), sizeof(T) * 2> {
 
 template <typename T, uint32_t Align, uint32_t Size>
 class RISCVGDGOT : public RISCVTGOT<T, Align, Size> {
+public:
+  static std::string getTypeName() { return "RISCVGDGOT"; }
+
 public:
   RISCVGDGOT(ELFSection *O, ResolveInfo *R)
       : RISCVTGOT<T, Align, Size>(GOT::TLS_GD, O, R),
@@ -137,6 +152,9 @@ class RISCVGDGOT : public RISCVTGOT<T, Align, Size> {
 
 template <typename T, uint32_t Align, uint32_t Size>
 class RISCVLDGOT : public RISCVTGOT<T, Align, Size> {
+public:
+  static std::string getTypeName() { return "RISCVLDGOT"; }
+
 public:
   RISCVLDGOT(ELFSection *O, ResolveInfo *R)
       : RISCVTGOT<T, Align, Size>(GOT::TLS_LD, O, R),
@@ -152,6 +170,9 @@ class RISCVLDGOT : public RISCVTGOT<T, Align, Size> {
 
 template <typename T, uint32_t Align, uint32_t Size>
 class RISCVIEGOT : public RISCVTGOT<T, Align, Size> {
+public:
+  static std::string getTypeName() { return "RISCVIEGOT"; }
+
 public:
   RISCVIEGOT(ELFSection *O, ResolveInfo *R)
       : RISCVTGOT<T, Align, Size>(GOT::TLS_IE, O, R) {}
diff --git a/lib/Target/RISCV/RISCVInfo.h b/lib/Target/RISCV/RISCVInfo.h
index 519b99783..bf1e4dbbe 100644
--- a/lib/Target/RISCV/RISCVInfo.h
+++ b/lib/Target/RISCV/RISCVInfo.h
@@ -14,6 +14,9 @@
 namespace eld {
 
 class RISCVInfo : public TargetInfo {
+public:
+  static std::string getTypeName() { return "RISCVInfo"; }
+
 public:
   RISCVInfo(LinkerConfig &m_Config);
 
diff --git a/lib/Target/RISCV/RISCVLDBackend.h b/lib/Target/RISCV/RISCVLDBackend.h
index 60bf02f42..848a3c629 100644
--- a/lib/Target/RISCV/RISCVLDBackend.h
+++ b/lib/Target/RISCV/RISCVLDBackend.h
@@ -30,6 +30,9 @@ class RISCVRelaxationStats;
 /// RISCVLDBackend - linker backend of RISCV target of GNU ELF format
 ///
 class RISCVLDBackend : public GNULDBackend {
+public:
+  static std::string getTypeName() { return "RISCVLDBackend"; }
+
 public:
   RISCVLDBackend(Module &pModule, RISCVInfo *pInfo);
 
diff --git a/lib/Target/RISCV/RISCVPLT.h b/lib/Target/RISCV/RISCVPLT.h
index 887894fcb..a6985849c 100644
--- a/lib/Target/RISCV/RISCVPLT.h
+++ b/lib/Target/RISCV/RISCVPLT.h
@@ -16,6 +16,9 @@ class RISCVGOT;
 class RISCVLDBackend;
 
 class RISCVPLT : public PLT {
+public:
+  static std::string getTypeName() { return "RISCVPLT"; }
+
 public:
   RISCVPLT(PLT::PLTType T, RISCVGOT *G, ELFSection *P, ResolveInfo *R,
            uint32_t Align, uint32_t Size)
@@ -37,6 +40,9 @@ class RISCVPLT : public PLT {
 
 template <typename T, uint32_t Align, uint32_t Size>
 class RISCVTPLT : public RISCVPLT {
+public:
+  static std::string getTypeName() { return "RISCVTPLT"; }
+
 public:
   // Going to be used by GOTPLT0
   RISCVTPLT(PLT::PLTType pltType, RISCVGOT *G, ELFSection *O, ResolveInfo *R)
@@ -47,6 +53,9 @@ class RISCVTPLT : public RISCVPLT {
 
 template <typename T, uint32_t Align, uint32_t Size>
 class RISCVPLT0 : public RISCVTPLT<T, Align, Size> {
+public:
+  static std::string getTypeName() { return "RISCVPLT0"; }
+
 public:
   RISCVPLT0(RISCVGOT *G, RISCVLDBackend &Backend, ELFSection *P)
       : RISCVTPLT<T, Align, Size>(PLT::PLT0, G, P, nullptr),
@@ -62,6 +71,9 @@ class RISCVPLT0 : public RISCVTPLT<T, Align, Size> {
 
 template <typename T, uint32_t Align, uint32_t Size>
 class RISCVPLTN : public RISCVTPLT<T, Align, Size> {
+public:
+  static std::string getTypeName() { return "RISCVPLTN"; }
+
 public:
   RISCVPLTN(RISCVGOT *G, ELFSection *P, ResolveInfo *R)
       : RISCVTPLT<T, Align, Size>(PLT::PLTN, G, P, R) {}
diff --git a/lib/Target/RISCV/RISCVRelaxationStats.h b/lib/Target/RISCV/RISCVRelaxationStats.h
index aff63fccb..3f3a50245 100644
--- a/lib/Target/RISCV/RISCVRelaxationStats.h
+++ b/lib/Target/RISCV/RISCVRelaxationStats.h
@@ -11,6 +11,9 @@
 
 namespace eld {
 class RISCVRelaxationStats : public LinkStats {
+public:
+  static std::string getTypeName() { return "RISCVRelaxationStats"; }
+
 public:
   RISCVRelaxationStats()
       : LinkStats("RelaxationStats", LinkStats::Kind::Relaxation) {}
diff --git a/lib/Target/RISCV/RISCVRelocator.cpp b/lib/Target/RISCV/RISCVRelocator.cpp
index 14529c5bd..e64bf6c22 100644
--- a/lib/Target/RISCV/RISCVRelocator.cpp
+++ b/lib/Target/RISCV/RISCVRelocator.cpp
@@ -27,6 +27,8 @@ typedef Relocator::Result (*ApplyFunctionType)(
     RelocationDescription &pRelocDesc);
 
 struct RelocationDescription {
+public:
+  static std::string getTypeName() { return "RelocationDescription"; }
   // The application function for the relocation.
   const ApplyFunctionType func;
   // The Relocation type, this is just kept for convenience when writing new
diff --git a/lib/Target/RISCV/RISCVRelocator.h b/lib/Target/RISCV/RISCVRelocator.h
index f40118e9c..6839b331d 100644
--- a/lib/Target/RISCV/RISCVRelocator.h
+++ b/lib/Target/RISCV/RISCVRelocator.h
@@ -22,6 +22,9 @@ class LinkerConfig;
  *
  */
 class RISCVRelocator : public Relocator {
+public:
+  static std::string getTypeName() { return "RISCVRelocator"; }
+
 public:
   RISCVRelocator(RISCVLDBackend &pParent, LinkerConfig &pConfig,
                  Module &pModule);
diff --git a/lib/Target/RISCV/RISCVStandaloneInfo.h b/lib/Target/RISCV/RISCVStandaloneInfo.h
index 18c9aef08..71c50942c 100644
--- a/lib/Target/RISCV/RISCVStandaloneInfo.h
+++ b/lib/Target/RISCV/RISCVStandaloneInfo.h
@@ -14,6 +14,9 @@
 namespace eld {
 
 class RISCVStandaloneInfo : public RISCVInfo {
+public:
+  static std::string getTypeName() { return "RISCVStandaloneInfo"; }
+
 public:
   RISCVStandaloneInfo(LinkerConfig &pConfig) : RISCVInfo(pConfig) {}
 
diff --git a/lib/Target/TargetInfo.cpp b/lib/Target/TargetInfo.cpp
index e1493e9de..357b244a1 100644
--- a/lib/Target/TargetInfo.cpp
+++ b/lib/Target/TargetInfo.cpp
@@ -22,6 +22,8 @@ using namespace eld;
 namespace {
 
 struct NameMap {
+public:
+  static std::string getTypeName() { return "NameMap"; }
   const char *from; ///< the prefix of the input string. (match FROM*)
   const char *to;   ///< the output string.
   InputSectDesc::Policy policy; /// mark whether the input is kept in GC
diff --git a/lib/Target/Template/TemplateInfo.h b/lib/Target/Template/TemplateInfo.h
index b72ef8cdd..1f080e074 100644
--- a/lib/Target/Template/TemplateInfo.h
+++ b/lib/Target/Template/TemplateInfo.h
@@ -13,6 +13,9 @@
 namespace eld {
 
 class TemplateInfo : public TargetInfo {
+public:
+  static std::string getTypeName() { return "TemplateInfo"; }
+
 public:
   TemplateInfo(LinkerConfig &m_Config);
 
diff --git a/lib/Target/Template/TemplateLDBackend.h b/lib/Target/Template/TemplateLDBackend.h
index 112d908d5..83799d8dd 100644
--- a/lib/Target/Template/TemplateLDBackend.h
+++ b/lib/Target/Template/TemplateLDBackend.h
@@ -23,6 +23,9 @@ class TemplateInfo;
 /// TemplateLDBackend - linker backend of Template target of GNU ELF format
 ///
 class TemplateLDBackend : public GNULDBackend {
+public:
+  static std::string getTypeName() { return "TemplateLDBackend"; }
+
 public:
   TemplateLDBackend(Module &pModule, TemplateInfo *pInfo);
 
diff --git a/lib/Target/Template/TemplateRelocationFunctions.h b/lib/Target/Template/TemplateRelocationFunctions.h
index ebf811cd6..81349c6c3 100644
--- a/lib/Target/Template/TemplateRelocationFunctions.h
+++ b/lib/Target/Template/TemplateRelocationFunctions.h
@@ -50,6 +50,8 @@ typedef Relocator::Result (*ApplyFunctionType)(
     RelocationDescription &pRelocDesc);
 
 struct RelocationDescription {
+public:
+  static std::string getTypeName() { return "RelocationDescription"; }
   // The application function for the relocation.
   const ApplyFunctionType func;
   // The Relocation type, this is just kept for convenience when writing new
@@ -63,10 +65,12 @@ struct RelocationDescription {
 };
 
 struct RelocationDescription RelocDesc[] = {
-    /* {  func =         &applyNone
-            ,  type =        llvm::ELF::
-            ,  forceVerify =  false
-    } */
+  public : static std::string getTypeName(){return "RelocationDescription";
+} // namespace eld
+/* {  func =         &applyNone
+        ,  type =        llvm::ELF::
+        ,  forceVerify =  false
+} */
 };
 
 } // namespace eld
diff --git a/lib/Target/Template/TemplateRelocator.h b/lib/Target/Template/TemplateRelocator.h
index 541d97f53..bd6854ac6 100644
--- a/lib/Target/Template/TemplateRelocator.h
+++ b/lib/Target/Template/TemplateRelocator.h
@@ -22,6 +22,9 @@ class LinkerConfig;
  *
  */
 class TemplateRelocator : public Relocator {
+public:
+  static std::string getTypeName() { return "TemplateRelocator"; }
+
 public:
   TemplateRelocator(TemplateLDBackend &pParent, LinkerConfig &pConfig,
                     Module &pModule);
diff --git a/lib/Target/Template/TemplateStandaloneInfo.h b/lib/Target/Template/TemplateStandaloneInfo.h
index fe51a5b90..117decc5c 100644
--- a/lib/Target/Template/TemplateStandaloneInfo.h
+++ b/lib/Target/Template/TemplateStandaloneInfo.h
@@ -15,6 +15,9 @@
 namespace eld {
 
 class TemplateStandaloneInfo : public TemplateInfo {
+public:
+  static std::string getTypeName() { return "TemplateStandaloneInfo"; }
+
 public:
   TemplateStandaloneInfo(LinkerConfig &pConfig) : TemplateInfo(pConfig) {}
 
diff --git a/lib/Target/x86_64/x86_64ELFDynamic.h b/lib/Target/x86_64/x86_64ELFDynamic.h
index a62105b71..8e7502f8f 100644
--- a/lib/Target/x86_64/x86_64ELFDynamic.h
+++ b/lib/Target/x86_64/x86_64ELFDynamic.h
@@ -12,6 +12,9 @@
 namespace eld {
 
 class x86_64ELFDynamic : public ELFDynamic {
+public:
+  static std::string getTypeName() { return "x86_64ELFDynamic"; }
+
 public:
   x86_64ELFDynamic(GNULDBackend &pParent, LinkerConfig &pConfig);
 
diff --git a/lib/Target/x86_64/x86_64GOT.h b/lib/Target/x86_64/x86_64GOT.h
index 65d02dea8..ebd4958bc 100644
--- a/lib/Target/x86_64/x86_64GOT.h
+++ b/lib/Target/x86_64/x86_64GOT.h
@@ -18,6 +18,9 @@ namespace eld {
  */
 
 class x86_64GOT : public GOT {
+public:
+  static std::string getTypeName() { return "x86_64GOT"; }
+
 public:
   // Going to be used by GOTPLT0
   x86_64GOT(GOTType T, ELFSection *O, ResolveInfo *R, uint32_t Align,
@@ -70,6 +73,9 @@ class x86_64GOT : public GOT {
  *  - [16-23]: Reserved for _dl_runtime_resolve (set by dynamic linker)
  */
 class x86_64GOTPLT0 : public x86_64GOT {
+public:
+  static std::string getTypeName() { return "x86_64GOTPLT0"; }
+
 public:
   x86_64GOTPLT0(ELFSection *O, Module *M)
       : x86_64GOT(GOT::GOTPLT0, O, nullptr, /*Align=*/8, /*Size=*/24), M(M) {}
@@ -106,6 +112,9 @@ class x86_64GOTPLT0 : public x86_64GOT {
  * case of lazy binding.
  */
 class x86_64GOTPLTN : public x86_64GOT {
+public:
+  static std::string getTypeName() { return "x86_64GOTPLTN"; }
+
 public:
   x86_64GOTPLTN(ELFSection *O, ResolveInfo *R)
       : x86_64GOT(GOT::GOTPLTN, O, R, /*Align=*/8, /*Size=*/8),
@@ -137,6 +146,9 @@ class x86_64GOTPLTN : public x86_64GOT {
 };
 
 class x86_64GDGOT : public x86_64GOT {
+public:
+  static std::string getTypeName() { return "x86_64GDGOT"; }
+
 public:
   x86_64GDGOT(ELFSection *O, ResolveInfo *R)
       : x86_64GOT(GOT::TLS_GD, O, R),
@@ -155,6 +167,9 @@ class x86_64GDGOT : public x86_64GOT {
 };
 
 class x86_64LDGOT : public x86_64GOT {
+public:
+  static std::string getTypeName() { return "x86_64LDGOT"; }
+
 public:
   x86_64LDGOT(ELFSection *O, ResolveInfo *R)
       : x86_64GOT(GOT::TLS_LD, O, R),
@@ -174,7 +189,10 @@ class x86_64LDGOT : public x86_64GOT {
 
 class x86_64IEGOT : public x86_64GOT {
 public:
-  x86_64IEGOT(ELFSection *O, ResolveInfo *R) : x86_64GOT(GOT::TLS_IE, O, R) {}
+  static std::string getTypeName() { return "x86_64IEGOT"; }
+
+public:
+  x86_64IEGOT(ELFSection *O, ResolveInfo *R) : x86_64GOT(GOT::TLS_LE, O, R) {}
 
   x86_64GOT *getFirst() override { return this; }
 
diff --git a/lib/Target/x86_64/x86_64Info.h b/lib/Target/x86_64/x86_64Info.h
index 3082ea969..fdedb90ff 100644
--- a/lib/Target/x86_64/x86_64Info.h
+++ b/lib/Target/x86_64/x86_64Info.h
@@ -14,6 +14,9 @@
 namespace eld {
 
 class x86_64Info : public TargetInfo {
+public:
+  static std::string getTypeName() { return "x86_64Info"; }
+
 public:
   x86_64Info(LinkerConfig &m_Config);
 
diff --git a/lib/Target/x86_64/x86_64LDBackend.h b/lib/Target/x86_64/x86_64LDBackend.h
index b9309bfde..a099606e1 100644
--- a/lib/Target/x86_64/x86_64LDBackend.h
+++ b/lib/Target/x86_64/x86_64LDBackend.h
@@ -24,6 +24,9 @@ class x86_64Info;
 /// x86_64LDBackend - linker backend of x86_64 target of GNU ELF format
 ///
 class x86_64LDBackend : public GNULDBackend {
+public:
+  static std::string getTypeName() { return "x86_64LDBackend"; }
+
 public:
   x86_64LDBackend(Module &pModule, x86_64Info *pInfo);
 
diff --git a/lib/Target/x86_64/x86_64PLT.h b/lib/Target/x86_64/x86_64PLT.h
index def991e94..801a17732 100644
--- a/lib/Target/x86_64/x86_64PLT.h
+++ b/lib/Target/x86_64/x86_64PLT.h
@@ -32,6 +32,9 @@ class x86_64GOT;
 class IRBuilder;
 
 class x86_64PLT : public PLT {
+public:
+  static std::string getTypeName() { return "x86_64PLT"; }
+
 public:
   x86_64PLT(PLT::PLTType T, eld::IRBuilder &I, x86_64GOT *G, ELFSection *P,
             ResolveInfo *R, uint32_t Align, uint32_t Size)
@@ -43,6 +46,9 @@ class x86_64PLT : public PLT {
 };
 
 class x86_64PLT0 : public x86_64PLT {
+public:
+  static std::string getTypeName() { return "x86_64PLT0"; }
+
 public:
   x86_64PLT0(x86_64GOT *G, eld::IRBuilder &I, ELFSection *P, ResolveInfo *R,
              uint32_t Align, uint32_t Size)
@@ -69,6 +75,9 @@ class x86_64PLT0 : public x86_64PLT {
  *  linker which .rela.plt entry corresponds to this function.
  */
 class x86_64PLTN : public x86_64PLT {
+public:
+  static std::string getTypeName() { return "x86_64PLTN"; }
+
 public:
   x86_64PLTN(x86_64GOT *G, eld::IRBuilder &I, ELFSection *P, ResolveInfo *R,
              uint32_t Align, uint32_t Size)
diff --git a/lib/Target/x86_64/x86_64RelocationFunctions.h b/lib/Target/x86_64/x86_64RelocationFunctions.h
index 2a1fef238..c0f3e879c 100644
--- a/lib/Target/x86_64/x86_64RelocationFunctions.h
+++ b/lib/Target/x86_64/x86_64RelocationFunctions.h
@@ -8,6 +8,7 @@
 
 #include "x86_64LLVMExtern.h"
 #include "x86_64Relocator.h"
+#include <string>
 
 namespace eld {
 
@@ -40,6 +41,8 @@ typedef Relocator::Result (*ApplyFunctionType)(
     RelocationDescription &pRelocDesc);
 
 struct RelocationDescription {
+public:
+  static std::string getTypeName() { return "RelocationDescription"; }
   // The application function for the relocation.
   const ApplyFunctionType func;
   // The Relocation type, this is just kept for convenience when writing new
diff --git a/lib/Target/x86_64/x86_64Relocator.h b/lib/Target/x86_64/x86_64Relocator.h
index b40c80b6b..989208ba1 100644
--- a/lib/Target/x86_64/x86_64Relocator.h
+++ b/lib/Target/x86_64/x86_64Relocator.h
@@ -26,6 +26,9 @@ class LinkerConfig;
  *
  */
 class x86_64Relocator : public Relocator {
+public:
+  static std::string getTypeName() { return "x86_64Relocator"; }
+
 public:
   x86_64Relocator(x86_64LDBackend &pParent, LinkerConfig &pConfig,
                   Module &pModule);
diff --git a/lib/Target/x86_64/x86_64StandaloneInfo.h b/lib/Target/x86_64/x86_64StandaloneInfo.h
index 9b73ae65c..f1ba8112f 100644
--- a/lib/Target/x86_64/x86_64StandaloneInfo.h
+++ b/lib/Target/x86_64/x86_64StandaloneInfo.h
@@ -14,6 +14,9 @@
 namespace eld {
 
 class x86_64StandaloneInfo : public x86_64Info {
+public:
+  static std::string getTypeName() { return "x86_64StandaloneInfo"; }
+
 public:
   x86_64StandaloneInfo(LinkerConfig &pConfig) : x86_64Info(pConfig) {}
 
diff --git a/test/Common/standalone/CommandLine/PrintMemoryReport/Inputs/1.c b/test/Common/standalone/CommandLine/PrintMemoryReport/Inputs/1.c
new file mode 100644
index 000000000..9fe07f82f
--- /dev/null
+++ b/test/Common/standalone/CommandLine/PrintMemoryReport/Inputs/1.c
@@ -0,0 +1 @@
+int foo() { return 0; }
diff --git a/test/Common/standalone/CommandLine/PrintMemoryReport/PrintMemoryReport.test b/test/Common/standalone/CommandLine/PrintMemoryReport/PrintMemoryReport.test
new file mode 100644
index 000000000..c548c41ea
--- /dev/null
+++ b/test/Common/standalone/CommandLine/PrintMemoryReport/PrintMemoryReport.test
@@ -0,0 +1,11 @@
+#---PrintmemoryReport.test--------------------------- Executable -----------------#
+#BEGIN_COMMENT
+# This checks if the linker supports --print-memory-report/--emit-memory-report option.
+#END_COMMENT
+#START_TEST
+RUN: %clang %clangopts -c %p/Inputs/1.c -o %t1.1.o
+RUN: %link %linkopts %t1.1.o -o %t2.out --print-memory-report 2>&1 | %filecheck %s --allow-empty
+RUN: %link %linkopts %t1.1.o -o %t2.out.1 --emit-memory-report=%t1.out.mem 2>&1
+RUN: %filecheck %s < %t1.out.mem
+#CHECK: Arena allocation report by type
+#END_TEST
diff --git a/tools/LSParserVerifier/LSParserVerifier.cpp b/tools/LSParserVerifier/LSParserVerifier.cpp
index 1d714d1bd..ded6affc8 100644
--- a/tools/LSParserVerifier/LSParserVerifier.cpp
+++ b/tools/LSParserVerifier/LSParserVerifier.cpp
@@ -29,6 +29,9 @@
 #include <memory>
 
 class CommonTargetInfo : public eld::TargetInfo {
+public:
+  static std::string getTypeName() { return "CommonTargetInfo"; }
+
 public:
   CommonTargetInfo(eld::LinkerConfig &config) : eld::TargetInfo(config) {}
 
@@ -45,6 +48,9 @@ class CommonTargetInfo : public eld::TargetInfo {
 };
 
 class CommonLDBackend : public eld::GNULDBackend {
+public:
+  static std::string getTypeName() { return "CommonLDBackend"; }
+
 public:
   CommonLDBackend(eld::Module &module, eld::TargetInfo *info)
       : GNULDBackend(module, info) {}
@@ -66,6 +72,8 @@ class CommonLDBackend : public eld::GNULDBackend {
 };
 
 class LinkerModel {
+public:
+  static std::string getTypeName() { return "LinkerModel"; }
   eld::DiagnosticEngine m_DiagEngine;
   eld::LinkerConfig *m_Config = nullptr;
   eld::LinkerScript *m_LinkerScript = nullptr;