Move AddressClass to private enums since API doesn't provide any functions to manage it.

This change allows to make AddressClass strongly typed enum and not to have issues with old versions of SWIG that don't support enum classes.

llvm-svn: 335710

lldb/include/lldb/API/SBAddress.h

@@ -80,8 +80,6 @@ public:
 
   lldb::SBLineEntry GetLineEntry();
 
-  lldb::AddressClass GetAddressClass();
-
 protected:
   friend class SBBlock;
   friend class SBBreakpointLocation;

lldb/include/lldb/API/SBInstruction.h

@@ -36,8 +36,6 @@ public:
 
   SBAddress GetAddress();
 
-  lldb::AddressClass GetAddressClass();
-
   const char *GetMnemonic(lldb::SBTarget target);
 
   const char *GetOperands(lldb::SBTarget target);

lldb/include/lldb/Core/Address.h

@@ -11,8 +11,8 @@
 #define liblldb_Address_h_
 
 #include "lldb/lldb-defines.h"      // for LLDB_INVALID_ADDRESS
-#include "lldb/lldb-enumerations.h" // for AddressClass::eInvalid
 #include "lldb/lldb-forward.h"      // for SectionWP, SectionSP, ModuleSP
+#include "lldb/lldb-private-enumerations.h" // for AddressClass
 #include "lldb/lldb-types.h"        // for addr_t
 
 #include <stddef.h> // for size_t
@@ -270,7 +270,7 @@ public:
             DumpStyle fallback_style = DumpStyleInvalid,
             uint32_t addr_byte_size = UINT32_MAX) const;
 
-  lldb::AddressClass GetAddressClass() const;
+  AddressClass GetAddressClass() const;
 
   //------------------------------------------------------------------
   /// Get the file address.
@@ -338,7 +338,7 @@ public:
   //------------------------------------------------------------------
   lldb::addr_t GetOpcodeLoadAddress(
       Target *target,
-      lldb::AddressClass addr_class = lldb::AddressClass::eInvalid) const;
+      AddressClass addr_class = AddressClass::eInvalid) const;
 
   //------------------------------------------------------------------
   /// Get the section relative offset value.
@@ -432,7 +432,7 @@ public:
 
   bool SetOpcodeLoadAddress(
       lldb::addr_t load_addr, Target *target,
-      lldb::AddressClass addr_class = lldb::AddressClass::eInvalid,
+      AddressClass addr_class = AddressClass::eInvalid,
       bool allow_section_end = false);
 
   bool SetCallableLoadAddress(lldb::addr_t load_addr, Target *target);

lldb/include/lldb/Core/Disassembler.h

@@ -22,8 +22,8 @@
 #include "lldb/Utility/ConstString.h" // for ConstString
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-defines.h"      // for DISALLOW_COPY_AND_ASSIGN
-#include "lldb/lldb-enumerations.h" // for AddressClass, AddressClass...
 #include "lldb/lldb-forward.h"      // for InstructionSP, DisassemblerSP
+#include "lldb/lldb-private-enumerations.h" // for AddressClass
 #include "lldb/lldb-types.h"        // for addr_t, offset_t
 
 #include "llvm/ADT/StringRef.h" // for StringRef
@@ -78,7 +78,7 @@ namespace lldb_private {
 class Instruction {
 public:
   Instruction(const Address &address,
-              lldb::AddressClass addr_class = lldb::AddressClass::eInvalid);
+              AddressClass addr_class = AddressClass::eInvalid);
 
   virtual ~Instruction();
 
@@ -102,11 +102,11 @@ public:
   virtual void
   CalculateMnemonicOperandsAndComment(const ExecutionContext *exe_ctx) = 0;
 
-  lldb::AddressClass GetAddressClass();
+  AddressClass GetAddressClass();
 
   void SetAddress(const Address &addr) {
     // Invalidate the address class to lazily discover it if we need to.
-    m_address_class = lldb::AddressClass::eInvalid;
+    m_address_class = AddressClass::eInvalid;
     m_address = addr;
   }
 
@@ -241,8 +241,8 @@ protected:
                      // when disassembling memory, you might run into data.
                      // This can help us to disassemble appropriately.
 private:
-  lldb::AddressClass
-      m_address_class; // Use GetAddressClass () accessor function!
+  AddressClass m_address_class; // Use GetAddressClass () accessor function!
+
 protected:
   Opcode m_opcode; // The opcode for this instruction
   std::string m_opcode_name;

lldb/include/lldb/Symbol/ObjectFile.h

@@ -241,7 +241,7 @@ public:
   ///     architecture (and object for archives). Returns zero if no
   ///     architecture or object has been selected.
   //------------------------------------------------------------------
-  virtual lldb::AddressClass GetAddressClass(lldb::addr_t file_addr);
+  virtual AddressClass GetAddressClass(lldb::addr_t file_addr);
 
   //------------------------------------------------------------------
   /// Extract the dependent modules from an object file.

lldb/include/lldb/Target/Target.h

@@ -739,7 +739,7 @@ public:
   //------------------------------------------------------------------
   lldb::addr_t GetCallableLoadAddress(
       lldb::addr_t load_addr,
-      lldb::AddressClass addr_class = lldb::AddressClass::eInvalid) const;
+      AddressClass addr_class = AddressClass::eInvalid) const;
 
   //------------------------------------------------------------------
   /// Get \a load_addr as an opcode for this target.
@@ -755,7 +755,7 @@ public:
   //------------------------------------------------------------------
   lldb::addr_t GetOpcodeLoadAddress(
       lldb::addr_t load_addr,
-      lldb::AddressClass addr_class = lldb::AddressClass::eInvalid) const;
+      AddressClass addr_class = AddressClass::eInvalid) const;
 
   // Get load_addr as breakable load address for this target. Take a addr and
   // check if for any reason there is a better address than this to put a

lldb/include/lldb/lldb-enumerations.h

@@ -813,26 +813,6 @@ enum FrameComparison {
   eFrameCompareOlder
 };
 
-//----------------------------------------------------------------------
-// Address Class
-//
-// A way of classifying an address used for disassembling and setting
-// breakpoints. Many object files can track exactly what parts of their object
-// files are code, data and other information. This is of course above and
-// beyond just looking at the section types. For example, code might contain PC
-// relative data and the object file might be able to tell us that an address
-// in code is data.
-//----------------------------------------------------------------------
-enum AddressClass {
-  eInvalid,
-  eUnknown,
-  eCode,
-  eCodeAlternateISA,
-  eData,
-  eDebug,
-  eRuntime
-};
-
 //----------------------------------------------------------------------
 // File Permissions
 //

lldb/include/lldb/lldb-private-enumerations.h

@@ -42,6 +42,26 @@ typedef enum AddressType {
                     ///this code
 } AddressType;
 
+//----------------------------------------------------------------------
+// Address Class
+//
+// A way of classifying an address used for disassembling and setting
+// breakpoints. Many object files can track exactly what parts of their object
+// files are code, data and other information. This is of course above and
+// beyond just looking at the section types. For example, code might contain PC
+// relative data and the object file might be able to tell us that an address
+// in code is data.
+//----------------------------------------------------------------------
+enum class AddressClass {
+  eInvalid,
+  eUnknown,
+  eCode,
+  eCodeAlternateISA,
+  eData,
+  eDebug,
+  eRuntime
+};
+
 //----------------------------------------------------------------------
 // Votes - Need a tri-state, yes, no, no opinion...
 //----------------------------------------------------------------------

lldb/scripts/interface/SBAddress.i

@@ -89,12 +89,8 @@ public:
     SBAddress::GetOffset ();
 
     void
-    SetAddress (lldb::SBSection section, 
+    SetAddress (lldb::SBSection section,
                 lldb::addr_t offset);
-             
-
-    lldb::AddressClass
-    GetAddressClass ();
 
     %feature("docstring", "
     //------------------------------------------------------------------

lldb/scripts/interface/SBInstruction.i

@@ -30,8 +30,6 @@ public:
     lldb::SBAddress
     GetAddress();
 
-    lldb::AddressClass
-    GetAddressClass ();
     
     const char *
     GetMnemonic (lldb::SBTarget target);

lldb/source/API/SBAddress.cpp

@@ -240,9 +240,3 @@ SBLineEntry SBAddress::GetLineEntry() {
   }
   return sb_line_entry;
 }
-
-AddressClass SBAddress::GetAddressClass() {
-  if (m_opaque_ap->IsValid())
-    return m_opaque_ap->GetAddressClass();
-  return AddressClass::eInvalid;
-}

lldb/source/API/SBInstruction.cpp

@@ -274,10 +274,3 @@ bool SBInstruction::TestEmulation(lldb::SBStream &output_stream,
     return inst_sp->TestEmulation(output_stream.get(), test_file);
   return false;
 }
-
-lldb::AddressClass SBInstruction::GetAddressClass() {
-  lldb::InstructionSP inst_sp(GetOpaque());
-  if (inst_sp)
-    return inst_sp->GetAddressClass();
-  return AddressClass::eInvalid;
-}

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

@@ -113,7 +113,7 @@ public:
 
   uint32_t GetAddressByteSize() const override;
 
-  lldb::AddressClass GetAddressClass(lldb::addr_t file_addr) override;
+  lldb_private::AddressClass GetAddressClass(lldb::addr_t file_addr) override;
 
   lldb_private::Symtab *GetSymtab() override;
 
@@ -191,7 +191,7 @@ private:
   typedef DynamicSymbolColl::iterator DynamicSymbolCollIter;
   typedef DynamicSymbolColl::const_iterator DynamicSymbolCollConstIter;
 
-  typedef std::map<lldb::addr_t, lldb::AddressClass>
+  typedef std::map<lldb::addr_t, lldb_private::AddressClass>
       FileAddressToAddressClassMap;
 
   /// Version of this reader common to all plugins based on this class.

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

@@ -86,7 +86,7 @@ public:
 
   uint32_t GetAddressByteSize() const override;
 
-  lldb::AddressClass GetAddressClass(lldb::addr_t file_addr) override;
+  lldb_private::AddressClass GetAddressClass(lldb::addr_t file_addr) override;
 
   lldb_private::Symtab *GetSymtab() override;