Read macro info from .debug_macro section and use it for expression evaluation.

[sivachandra]

Summary

DWARF 5 proposes a reinvented .debug_macro section. This change follows
that spec.

Currently, only GCC produces the .debug_macro section and hence
the added test is annottated with expectedFailureClang.

[sivachandra]

The dwo_test_method fails for the added test as I think there is some GCC bug with the combination of -gsplit-dwarf and -g3.

[sivachandra]

I should also mention that I did not implement the complete spec as I do not know of any producer which produces all the flavors of the new spec.

[tberghammer]

The high level architecture looks reasonable but there are a few think I would like you to clean up a bit:

• Several of your function uses a raw "new ...()" and then returns a pointer. Please put the data into a smart pointer (usually std::unique_ptr) and return that one instead to eliminate the risk of a memory leak.
• I added a bunch of inline comments. Most of them are minor style issues but there are some more significant ones (e.g. unused data structures)

How much advantage do you expect from this change from the users point of view? Do you think we should try to make clang produce .debug_macros section also?

In case of split dwarf gcc produces several .debug_macro.dwo section for each compile unit what won't work with your current implementation. I haven't checked the spec if gcc-s behavior is correct or not but it might be a good idea to support it (not necessary with this change). If you decide to not support split dwarf then please mark the test as XFAIL(dwo) also

include/lldb/Symbol/DebugMacros.h

57

(nit): "= default" (for all other similar function also)

132

(nit): Please use nullptr (for all other similar case also)

138

What is the benefit of storing unique pointers in the vector compared to the objects itself?

source/Expression/ExpressionSourceCode.cpp

106

(nit): Please mark this function static and move it out from the anonymous namespace

122

Should this function return an error in this case so the caller know the macro stream is only half ready?

source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp

57–59

(nit): Please initialize

source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.h

29

Please move this enum out from the global namespace (preferably into one of the class) as we are currently leaking both the enum name and the enum fields into the global namespace.

39

(nit): struct

48

(nit): Member variable names should start with "m_"

49

Why do we need this data structure? Currently nobody is using it.
Also should we store DWARFFormValue instead of llvm::dwarf::Form here? It have a lot of feature in it what makes it work with split dwarf (dwo).

[clayborg]

My main concern here is efficient storage. See my inline comment regarding DebugMacroEntryStorage and let me know what you think.

include/lldb/Symbol/DebugMacros.h

99

You can probably drop this to uint32_t. No one will have a file with more than 4 billions lines of code. Then this class will pack better.

101

m_file should be stored as an integer. CompileUnits has a CompileUnits::GetSupportFiles() which is the file list that is the same list from the DWARF line table file table. This doesn't mean that we have to hand it to consumers as an index, see my comments below about DebugMacroEntryStorage

102

We are going to have a million of these objects and we should really store this as efficiently as possible:

DebugMacroEntryStorage
{
    uint32_t m_type:3;
    uint32_t m_line:29;
    uint32_t m_file_idx; // Index to file in CompileUnit::GetSupportFiles() FileSpecList
    ConstString m_str;
};

Then you can expand this into an instance of DebugMacroEntry and have that be what you hand out to external users and this DebugMacroEntry can be as big as you want. Can we inline the entries that are currently representing by adding the m_debug_macros_sp here? Do we really have many places in the macros for a file that include the same thing over and over? I would vote we get rid of the m_debug_macros_sp and just inline the entries where we need to unless we have a specific case where this would make us make way too many DebugMacroEntryStorage objects.

138

I would rather see this as a vector of just the structs as well as tberghammer suggests. No need to scatter thousands of objects around the heap if we don't need to.

source/Expression/ExpressionSourceCode.cpp

242

Remove this as it isn't needed. The StreamString has a std::string and it doesn't need to have anything in it to say it is empty.

[sivachandra]

Address comments.

[sivachandra]

I have addressed all the comments (with changes or my own comments).

About the problem with dwo, I have sent a mail to the GCC guys asking for guidance. Will fix it when I get clarity on that.

And yes, it would definitely be good if clang can also produce .debug_macro sections.

include/lldb/Symbol/DebugMacros.h

102

1. I have taken in other changes but did not remove m_debug_macros_sp.
2. I have removed the file name / file index member completely as we are not using it now anyway!
3. I did not understand the benefit of creating a new class/struct.
4. For a simple source file like in the test, I see a 100+ defines inserted by default. If we inline them, and if a symbol file contains a 100 simple source files, we will be storing 10000+ duplicate entries. If each of the source files actually includes a standard library header, I would image there would be many more common entries exploding the number of duplicate entries we will be storing.

source/Expression/ExpressionSourceCode.cpp

122

The return here does not mean it is "half ready". The function returns from here as macro entries after this appear on or after the current line in the main source file.

source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.h

49

I have refactored the code around this now. Since the entire header has to be read past to get to the macro entries, I have collected the data in a data-structure. After the refactor, it is only lives on the stack. While I am OK to take it off if you want, I see no harm in keeping it as a data structure.

Also, since the form value is unused anyway, I have now made it dw_form_t.

[clayborg]

Can we change DebugMacroEntry to contain a std::unique_ptr<DebugMacro> instead of a shared pointer? This would save us one full pointer in each DebugMacroEntry.

That is the only change I would like to see.

The expand on the benefit of having two structs like DebugMacroEntryStorage would be you can store it very efficiently with bitfields and store the macros inside DebugMacro as a vector of DebugMacroEntryStorage structs. But the API from DebugMacro could that gets an entry at index could return the bigger fatter version of this. The two structs below would be an example:

We store macro entries inside DebugMacro as:

class DebugMacroEntryStorage
{
    EntryType m_type:3;
    uint32_t m_line:29;
    uint32_t m_file;
    ConstString m_str;
    DebugMacrosSP m_debug_macros_sp;
};

But the function:

DebugMacroEntry
GetMacroEntryAtIndex(const size_t index) const

would return something like:

class DebugMacroEntryStorage
{
    CompileUnit *m_comp_unit;
    EntryType m_type;
    uint32_t m_line;
    FileSpec m_file;
    ConstString m_str;
    DebugMacrosSP m_debug_macros_sp;
};

We would resolve the "m_file" into a FileSpec for public consumption by getting the correct file from the compile unit's support files FileSpecList and not compress the storage and also fill in the m_comp_unit if needed.

This doesn't need to be done, but this is what I was thinking. I did this in LineTable.h where I store line entries as a lldb_private::LineTable::Entry objects, but I hand them out to clients as lldb_private::LineEntry objects.

[clayborg]

In D15437#308839, @clayborg wrote:

Can we change DebugMacroEntry to contain a std::unique_ptr<DebugMacro> instead of a shared pointer? This would save us one full pointer in each DebugMacroEntry.

That is the only change I would like to see.

Actually never mind. I believe the whole reason this shared pointer is here it to share the object between multiple other objects...

[clayborg]

One area of concern is if you are not tracking file, how can you get the right defines for a given source file line? If you have:

main.c:

#include <foo.h>
#define FOO printf

int main ()
{
    return 0; // Stop here and run: FOO("hello world\n")
}

#undef FOO

But in foo.h you have:
#define FOO puts

nothing
nothing
nothing
nothing

#undef FOO

Do you currently correctly have the following in your macros if stopped at the return statement in main?

#define FOO puts <<< from foo.h
#undef FOO <<< from foo.h
#define FOO print <<< from main.c

Both foo definitions will be on line 1, and we will be stopped on line 5 of main.c, but if we don't know that the entries from foo.h come from foo.h we might accidentally include these statements?

[sivachandra]

The spec says that, for a given compile unit, the macro entries in the debug info will be in the order in which the compiler processes them. Hence, at line 5 in your example, all these are relevant:

#define FOO puts <<< from foo.h
#undef FOO <<< from foo.h
#define FOO print <<< from main.c

I have actually verified that it works as expected; FOO resolves to printf and not puts at line 5.

You have tickled one aspect that I have ignored though. What if one is stopped in an inlined function/method defined in an included file? I think taking care of this is a fairly straightforward change over what I now have. I will need to bring back the line index in DebugMacroEntry and use it. Will send an update soon.

[sivachandra]

Use file names.

[sivachandra]

PTAL. I have now covered the case I missed. Added test for that as well.

[tberghammer]

source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp

39–42

If we can get rid of all OperandTable related data then this can become a call to the SkipOperandTable function. (What is the purpose of the operand table if you can process everything without using it?).

source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.h

50

Constructing it is quite expensive as we insert a new entry for each operand into a std::map what will involve a binary search and most likely a heap allocation. As we don't use it for anything I would prefer to remove it because we don't want to pay the computation cost required to create it for nothing. We can add it back when we have a use case for it.

Going forward in this route I don't see any code reading DWARFDebugMacroHeader::m_operand_table either. I might miss something but if nobody is reading it then we can remove DWARFDebugMacroHeader::m_operand_table, DWARFDebugMacroHeader::OperandTable, DWARFDebugMacroHeader::OperandTableEntry and the call to DWARFDebugMacroHeader::OperandTable::ReadOperandTable what would simplify the code and also improve the efficiency as we don't do a lot of useless work.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

564

Should we use std::map or std::unordered_map here?

[sivachandra]

Remove storing of an unused data structure.

[sivachandra]

Use std::unordered_map instead of std::map.

[sivachandra]

PTAL

[tberghammer]

LGTM

include/lldb/Symbol/CompileUnit.h

 //===-- CompileUnit.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_CompUnit_h_
 #define liblldb_CompUnit_h_
 
 #include "lldb/lldb-enumerations.h"
+#include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/ModuleChild.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/UserID.h"
 
 namespace lldb_private {
 //----------------------------------------------------------------------
public:
     ///
     /// @return
     ///     The line table object pointer, or NULL if this line table
     ///     hasn't been parsed yet.
     //------------------------------------------------------------------
     LineTable*
     GetLineTable ();
 
+    DebugMacros*
+    GetDebugMacros ();
+
     //------------------------------------------------------------------
     /// Get the compile unit's support file list.
     ///
     /// The support file list is used by the line table, and any objects
     /// that have valid Declaration objects.
     ///
     /// @return
     ///     A support file list object.
public:
     /// object when it is deleted.
     ///
     /// @param[in] line_table
     ///     A line table object pointer that this object now owns.
     //------------------------------------------------------------------
     void
     SetLineTable(LineTable* line_table);
 
+    void
+    SetDebugMacros(const DebugMacrosSP &debug_macros);
+
     //------------------------------------------------------------------
     /// Set accessor for the variable list.
     ///
     /// Called by the SymbolFile plug-ins after they have parsed the
     /// variable lists and are ready to hand ownership of the list over
     /// to this object.
     ///
     /// @param[in] variable_list_sp
protected:
     lldb::LanguageType m_language; ///< The programming language enumeration value.
     Flags m_flags; ///< Compile unit flags that help with partial parsing.
     std::vector<lldb::FunctionSP> m_functions; ///< The sparsely populated list of shared pointers to functions
                                          ///< that gets populated as functions get partially parsed.
     std::vector<ConstString> m_imported_modules; ///< All modules, including the current module, imported by this
                                                  ///< compile unit.
     FileSpecList m_support_files; ///< Files associated with this compile unit's line table and declarations.
     std::unique_ptr<LineTable> m_line_table_ap; ///< Line table that will get parsed on demand.
+    DebugMacrosSP m_debug_macros_sp; ///< Debug macros that will get parsed on demand.
     lldb::VariableListSP m_variables; ///< Global and static variable list that will get parsed on demand.
     bool       m_is_optimized; /// eLazyBoolYes if this compile unit was compiled with optimization.
 
 private:
     enum
     {
         flagsParsedAllFunctions     = (1u << 0), ///< Have we already parsed all our functions
         flagsParsedVariables        = (1u << 1), ///< Have we already parsed globals and statics?
         flagsParsedSupportFiles     = (1u << 2), ///< Have we already parsed the support files for this compile unit?
         flagsParsedLineTable        = (1u << 3), ///< Have we parsed the line table already?
         flagsParsedLanguage         = (1u << 4), ///< Have we parsed the language already?
-        flagsParsedImportedModules  = (1u << 5)  ///< Have we parsed the imported modules already?
+        flagsParsedImportedModules  = (1u << 5), ///< Have we parsed the imported modules already?
+        flagsParsedDebugMacros      = (1u << 6)  ///< Have we parsed the debug macros already?
     };
 
     DISALLOW_COPY_AND_ASSIGN (CompileUnit);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_CompUnit_h_

include/lldb/Symbol/DebugMacros.h

+//===-- DebugMacros.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_DebugMacros_h_
+#define liblldb_DebugMacros_h_
+
+// C Includes
+// C++ Includes
+#include <memory>
+#include <vector>
+
+// Other libraries and framework includes
+// Project includes
+#include "lldb/lldb-private.h"
+#include "lldb/Core/ConstString.h"
+
+namespace lldb_private {
+
+class CompileUnit;
+class DebugMacros;
+typedef std::shared_ptr<DebugMacros> DebugMacrosSP;
+
+class DebugMacroEntry
+{
+public:
+    enum EntryType
+    {
+        INVALID,
+        DEFINE,
+        UNDEF,
+        START_FILE,
+        END_FILE,
+        INDIRECT
+    };
+
+public:
+    static DebugMacroEntry
+    CreateDefineEntry(uint32_t line, const char *str);
+
+    static DebugMacroEntry
+    CreateUndefEntry(uint32_t line, const char *str);
+
+    static DebugMacroEntry
+    CreateStartFileEntry(uint32_t line, uint32_t debug_line_file_idx);
+
+    static DebugMacroEntry
+    CreateEndFileEntry();
+
+    static DebugMacroEntry
+    CreateIndirectEntry(const DebugMacrosSP &debug_macros_sp);
+
+    DebugMacroEntry() : m_type(INVALID) { }
+
+    ~DebugMacroEntry() = default;
+
+    EntryType
+    GetType() const
+    {
+        return m_type;
+    }
+
+    uint64_t
+    GetLineNumber() const
+    {
+        return m_line;
+    }
+
+    ConstString
+    GetMacroString() const
+    {
+        return m_str;
+    }
+
+    const FileSpec& GetFileSpec(CompileUnit *comp_unit) const;
+
+    DebugMacros *
+    GetIndirectDebugMacros() const
+    {
+        return m_debug_macros_sp.get();
+    }
+
+private:
+    DebugMacroEntry(EntryType type,
+                    uint32_t line,
+                    uint32_t debug_line_file_idx,
+                    const char *str);
+
+    DebugMacroEntry(EntryType type,
+                    const DebugMacrosSP &debug_macros_sp);
+
+    EntryType m_type:3;
+    uint32_t m_line:29;
+    uint32_t m_debug_line_file_idx;
+    ConstString m_str;
+    DebugMacrosSP m_debug_macros_sp;
+};
+
+class DebugMacros
+{
+public:
+    DebugMacros() = default;
+
+    ~DebugMacros() = default;
+
+    void
+    AddMacroEntry(const DebugMacroEntry &entry)
+    {
+        m_macro_entries.push_back(entry);
+    }
+
+    size_t
+    GetNumMacroEntries() const
+    {
+        return m_macro_entries.size();
+    }
+
+    DebugMacroEntry
+    GetMacroEntryAtIndex(const size_t index) const
+    {
+        if (index < m_macro_entries.size())
+            return m_macro_entries[index];
+        else
+            return DebugMacroEntry();
+    }
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(DebugMacros);
+
+    std::vector<DebugMacroEntry> m_macro_entries;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_DebugMacros_h_

include/lldb/Symbol/SymbolFile.h

public:
     //------------------------------------------------------------------
     // Approach 1 - iterator
     virtual uint32_t        GetNumCompileUnits() = 0;
     virtual lldb::CompUnitSP  ParseCompileUnitAtIndex(uint32_t index) = 0;
 
     virtual lldb::LanguageType ParseCompileUnitLanguage (const SymbolContext& sc) = 0;
     virtual size_t          ParseCompileUnitFunctions (const SymbolContext& sc) = 0;
     virtual bool            ParseCompileUnitLineTable (const SymbolContext& sc) = 0;
+    virtual bool            ParseCompileUnitDebugMacros (const SymbolContext& sc) = 0;
     virtual bool            ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files) = 0;
     virtual bool            ParseImportedModules (const SymbolContext &sc, std::vector<ConstString> &imported_modules) = 0;
     virtual size_t          ParseFunctionBlocks (const SymbolContext& sc) = 0;
     virtual size_t          ParseTypes (const SymbolContext& sc) = 0;
     virtual size_t          ParseVariablesForContext (const SymbolContext& sc) = 0;
     virtual Type*           ResolveTypeUID (lldb::user_id_t type_uid) = 0;
     virtual bool            CompleteType (CompilerType &compiler_type) = 0;
     virtual void            ParseDeclsForContext (CompilerDeclContext decl_ctx) {}

include/lldb/Symbol/SymbolVendor.h

public:
     
     virtual size_t
     ParseCompileUnitFunctions (const SymbolContext& sc);
 
     virtual bool
     ParseCompileUnitLineTable (const SymbolContext& sc);
 
     virtual bool
+    ParseCompileUnitDebugMacros (const SymbolContext& sc);
+
+    virtual bool
     ParseCompileUnitSupportFiles (const SymbolContext& sc,
                                   FileSpecList& support_files);
     
     virtual bool
     ParseImportedModules (const SymbolContext &sc,
                           std::vector<ConstString> &imported_modules);
 
     virtual size_t

include/lldb/lldb-enumerations.h

enum SectionType
         eSectionTypeDWARFDebugAbbrev,
         eSectionTypeDWARFDebugAddr,
         eSectionTypeDWARFDebugAranges,
         eSectionTypeDWARFDebugFrame,
         eSectionTypeDWARFDebugInfo,
         eSectionTypeDWARFDebugLine,
         eSectionTypeDWARFDebugLoc,
         eSectionTypeDWARFDebugMacInfo,
+        eSectionTypeDWARFDebugMacro,
         eSectionTypeDWARFDebugPubNames,
         eSectionTypeDWARFDebugPubTypes,
         eSectionTypeDWARFDebugRanges,
         eSectionTypeDWARFDebugStr,
         eSectionTypeDWARFDebugStrOffsets,
         eSectionTypeDWARFAppleNames,
         eSectionTypeDWARFAppleTypes,
         eSectionTypeDWARFAppleNamespaces,

packages/Python/lldbsuite/test/expression_command/macros/Makefile

+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+
+DEBUG_INFO_FLAG = -g3
+
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/expression_command/macros/TestMacros.py

+import lldb
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+
+class TestMacros(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @expectedFailureClang("clang does not emit .debug_macro[.dwo] sections.")
+    @expectedFailureDwo("GCC produces multiple .debug_macro.dwo sections and the spec is unclear as to what it means")
+    def test_expr_with_macros(self):
+        self.build()
+
+        # Get main source file
+        src_file = "main.cpp"
+        hdr_file = "macro1.h"
+        src_file_spec = lldb.SBFileSpec(src_file)
+        self.assertTrue(src_file_spec.IsValid(), "Main source file")
+
+        # Get the path of the executable
+        cwd = os.getcwd()
+        exe_file = "a.out"
+        exe_path  = os.path.join(cwd, exe_file)
+
+        # Load the executable
+        target = self.dbg.CreateTarget(exe_path)
+        self.assertTrue(target.IsValid(), VALID_TARGET)
+
+        # Set breakpoints
+        bp1 = target.BreakpointCreateBySourceRegex("Break here", src_file_spec)
+        self.assertTrue(bp1.IsValid() and bp1.GetNumLocations() >= 1, VALID_BREAKPOINT)
+
+        # Launch the process
+        process = target.LaunchSimple(None, None, self.get_process_working_directory())
+        self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
+
+        # Get the thread of the process
+        self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+
+        # Get frame for current thread
+        frame = thread.GetSelectedFrame()
+
+        result = frame.EvaluateExpression("MACRO_1")
+        self.assertTrue(result.IsValid() and result.GetValue() == "100", "MACRO_1 = 100")
+
+        result = frame.EvaluateExpression("MACRO_2")
+        self.assertTrue(result.IsValid() and result.GetValue() == "200", "MACRO_2 = 200")
+
+        result = frame.EvaluateExpression("ONE")
+        self.assertTrue(result.IsValid() and result.GetValue() == "1", "ONE = 1")
+
+        result = frame.EvaluateExpression("TWO")
+        self.assertTrue(result.IsValid() and result.GetValue() == "2", "TWO = 2")
+
+        result = frame.EvaluateExpression("THREE")
+        self.assertTrue(result.IsValid() and result.GetValue() == "3", "THREE = 3")
+
+        result = frame.EvaluateExpression("FOUR")
+        self.assertTrue(result.IsValid() and result.GetValue() == "4", "FOUR = 4")
+
+        result = frame.EvaluateExpression("HUNDRED")
+        self.assertTrue(result.IsValid() and result.GetValue() == "100", "HUNDRED = 100")
+
+        result = frame.EvaluateExpression("THOUSAND")
+        self.assertTrue(result.IsValid() and result.GetValue() == "1000", "THOUSAND = 1000")
+
+        result = frame.EvaluateExpression("MILLION")
+        self.assertTrue(result.IsValid() and result.GetValue() == "1000000", "MILLION = 1000000")
+
+        result = frame.EvaluateExpression("MAX(ONE, TWO)")
+        self.assertTrue(result.IsValid() and result.GetValue() == "2", "MAX(ONE, TWO) = 2")
+
+        result = frame.EvaluateExpression("MAX(THREE, TWO)")
+        self.assertTrue(result.IsValid() and result.GetValue() == "3", "MAX(THREE, TWO) = 3")
+
+        # Get the thread of the process
+        thread.StepOver()
+
+        # Get frame for current thread
+        frame = thread.GetSelectedFrame()
+
+        result = frame.EvaluateExpression("MACRO_2")
+        self.assertTrue(result.GetError().Fail(), "Printing MACRO_2 fails in the mail file")
+
+        result = frame.EvaluateExpression("FOUR")
+        self.assertTrue(result.GetError().Fail(), "Printing FOUR fails in the main file")
+
+        thread.StepInto()
+
+        # Get frame for current thread
+        frame = thread.GetSelectedFrame()
+
+        result = frame.EvaluateExpression("ONE")
+        self.assertTrue(result.IsValid() and result.GetValue() == "1", "ONE = 1")
+
+        result = frame.EvaluateExpression("MAX(ONE, TWO)")
+        self.assertTrue(result.IsValid() and result.GetValue() == "2", "MAX(ONE, TWO) = 2")
+
+        # This time, MACRO_1 and MACRO_2 are not visible.
+        result = frame.EvaluateExpression("MACRO_1")
+        self.assertTrue(result.GetError().Fail(), "Printing MACRO_1 fails in the header file")
+
+        result = frame.EvaluateExpression("MACRO_2")
+        self.assertTrue(result.GetError().Fail(), "Printing MACRO_2 fails in the header file")

packages/Python/lldbsuite/test/expression_command/macros/macro1.h

+
+#include "macro2.h"
+
+#define ONE 1
+#define TWO 2
+#define THREE 3
+#define FOUR 4
+
+class Simple
+{
+public:
+    int
+    Method()
+    {
+        return ONE + TWO;
+    };
+};

packages/Python/lldbsuite/test/expression_command/macros/macro2.h

+#define HUNDRED 100
+#define THOUSAND 1000
+#define MILLION 1000000
+
+#define MAX(a, b)\
+((a) > (b) ?\
+  (a):\
+  (b))

packages/Python/lldbsuite/test/expression_command/macros/main.cpp

+#include "macro1.h"
+
+#define MACRO_1 100
+#define MACRO_2 200
+
+int
+main ()
+{
+  int a = ONE + TWO; // Break here
+
+  #undef MACRO_2
+  #undef FOUR
+
+  return Simple().Method();
+}

packages/Python/lldbsuite/test/make/Makefile.rules

else
   endif
 endif
 
 LIMIT_DEBUG_INFO_FLAGS =
 ifneq (,$(findstring clang,$(CC)))
    LIMIT_DEBUG_INFO_FLAGS += -flimit-debug-info
 endif
 
-CFLAGS ?= -g -O0 -fno-builtin
+DEBUG_INFO_FLAG ?= -g
+
+CFLAGS ?= $(DEBUG_INFO_FLAG) -O0 -fno-builtin
 ifeq "$(OS)" "Darwin"
   CFLAGS += $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS) -I$(LLDB_BASE_DIR)include
 else
   CFLAGS += $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS) -I$(LLDB_BASE_DIR)include
 endif
 
 CFLAGS += -include $(THIS_FILE_DIR)test_common.h $(TRIPLE_CFLAGS)
 

source/Expression/ExpressionSourceCode.cpp

 //===-- ExpressionSourceCode.cpp --------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Expression/ExpressionSourceCode.h"
 
 #include "lldb/Core/StreamString.h"
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
+#include "lldb/Symbol/CompileUnit.h"
+#include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb_private;

 typedef __PTRDIFF_TYPE__ ptrdiff_t;
 typedef unsigned short unichar;
 extern "C"
 {
     int printf(const char * __restrict, ...);
 }
 )";
 
+namespace {
+
+class AddMacroState
+{
+    enum State
+    {
+        CURRENT_FILE_NOT_YET_PUSHED,
+        CURRENT_FILE_PUSHED,
+        CURRENT_FILE_POPPED
+    };
+
+public:
+    AddMacroState(const FileSpec &current_file, const uint32_t current_file_line)
+        : m_state(CURRENT_FILE_NOT_YET_PUSHED),
+          m_current_file(current_file),
+          m_current_file_line(current_file_line)
+    { }
+
+    void
+    StartFile(const FileSpec &file)
+    {
+        m_file_stack.push_back(file);
+        if (file == m_current_file)
+            m_state = CURRENT_FILE_PUSHED;
+    }
+
+    void
+    EndFile()
+    {
+        if (m_file_stack.size() == 0)
+            return;
+
+        FileSpec old_top = m_file_stack.back();
+        m_file_stack.pop_back();
+        if (old_top == m_current_file)
+            m_state = CURRENT_FILE_POPPED;
+    }
+
+    // An entry is valid if it occurs before the current line in
+    // the current file.
+    bool
+    IsValidEntry(uint32_t line)
+    {
+        switch (m_state)
+        {
+            case CURRENT_FILE_NOT_YET_PUSHED:
+                return true;
+            case CURRENT_FILE_POPPED:
+                return false;
+            case CURRENT_FILE_PUSHED:
+                // If we are in file included in the current file,
+                // the entry should be added.
+                if (m_file_stack.back() != m_current_file)
+                    return true;
+
+                if (line >= m_current_file_line)
+                    return false;
+                else
+                    return true;
+        }
+    }
+
+private:
+    std::vector<FileSpec> m_file_stack;
+    State m_state;
+    FileSpec m_current_file;
+    uint32_t m_current_file_line;
+};
+
+} // anonymous namespace
+
+static void
+AddMacros(const DebugMacros *dm, CompileUnit *comp_unit, AddMacroState &state, StreamString &stream)
+{
+    if (dm == nullptr)
+        return;
+
+    for (size_t i = 0; i < dm->GetNumMacroEntries(); i++)
+    {
+        const DebugMacroEntry &entry = dm->GetMacroEntryAtIndex(i);
+        uint32_t line;
+
+        switch (entry.GetType())
+        {
+            case DebugMacroEntry::DEFINE:
+                if (state.IsValidEntry(entry.GetLineNumber()))
+                    stream.Printf("#define %s\n", entry.GetMacroString().AsCString());
+                else
+                    return;
+                break;
+            case DebugMacroEntry::UNDEF:
+                if (state.IsValidEntry(entry.GetLineNumber()))
+                    stream.Printf("#undef %s\n", entry.GetMacroString().AsCString());
+                else
+                    return;
+                break;
+            case DebugMacroEntry::START_FILE:
+                line = entry.GetLineNumber();
+                if (state.IsValidEntry(line))
+                    state.StartFile(entry.GetFileSpec(comp_unit));
+                else
+                    return;
+                break;
+            case DebugMacroEntry::END_FILE:
+                state.EndFile();
+                break;
+            case DebugMacroEntry::INDIRECT:
+                AddMacros(entry.GetIndirectDebugMacros(), comp_unit, state, stream);
+                break;
+            default:
+                // This is an unknown/invalid entry. Ignore.
+                break;
+        }
+    }
+}
 
 bool ExpressionSourceCode::GetText (std::string &text, lldb::LanguageType wrapping_language, bool const_object, bool static_method, ExecutionContext &exe_ctx) const
 {
     const char *target_specific_defines = "typedef signed char BOOL;\n";
     std::string module_macros;
     
     if (Target *target = exe_ctx.GetTargetPtr())
     {
if (Target *target = exe_ctx.GetTargetPtr())
             decl_vendor->ForEachMacro(modules_for_macros, [&module_macros] (const std::string &expansion) -> bool {
                 module_macros.append(expansion);
                 module_macros.append("\n");
                 return false;
             });
         }
 
     }
-    
+    StreamString debug_macros_stream;
+    if (StackFrame *frame = exe_ctx.GetFramePtr())
+    {
+        const SymbolContext &sc = frame->GetSymbolContext(
+           lldb:: eSymbolContextCompUnit | lldb::eSymbolContextLineEntry);
+
+        if (sc.comp_unit && sc.line_entry.IsValid())
+        {
+            DebugMacros *dm = sc.comp_unit->GetDebugMacros();
+            if (dm)
+            {
+                AddMacroState state(sc.line_entry.file, sc.line_entry.line);
+                AddMacros(dm, sc.comp_unit, state, debug_macros_stream);
+            }
+        }
+    }
+    
     if (m_wrap)
     {
         switch (wrapping_language) 
         {
         default:
             return false;
         case lldb::eLanguageTypeC:
         case lldb::eLanguageTypeC_plus_plus:
         case lldb::eLanguageTypeObjC:
             break;
         }
         
         StreamString wrap_stream;
         
-        wrap_stream.Printf("%s\n%s\n%s\n%s\n",
+        wrap_stream.Printf("%s\n%s\n%s\n%s\n%s\n",
                            module_macros.c_str(),
+                           debug_macros_stream.GetData(),
                            g_expression_prefix,
                            target_specific_defines,
                            m_prefix.c_str());
         
         switch (wrapping_language) 
         {
         default:
             break;

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (!m_sections_ap.get() && ParseSectionHeaders())
             static ConstString g_sect_name_dwarf_debug_abbrev (".debug_abbrev");
             static ConstString g_sect_name_dwarf_debug_addr (".debug_addr");
             static ConstString g_sect_name_dwarf_debug_aranges (".debug_aranges");
             static ConstString g_sect_name_dwarf_debug_frame (".debug_frame");
             static ConstString g_sect_name_dwarf_debug_info (".debug_info");
             static ConstString g_sect_name_dwarf_debug_line (".debug_line");
             static ConstString g_sect_name_dwarf_debug_loc (".debug_loc");
             static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo");
+            static ConstString g_sect_name_dwarf_debug_macro (".debug_macro");
             static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames");
             static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes");
             static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges");
             static ConstString g_sect_name_dwarf_debug_str (".debug_str");
             static ConstString g_sect_name_dwarf_debug_str_offsets (".debug_str_offsets");
             static ConstString g_sect_name_dwarf_debug_abbrev_dwo (".debug_abbrev.dwo");
             static ConstString g_sect_name_dwarf_debug_info_dwo (".debug_info.dwo");
             static ConstString g_sect_name_dwarf_debug_line_dwo (".debug_line.dwo");
+            static ConstString g_sect_name_dwarf_debug_macro_dwo (".debug_macro.dwo");
             static ConstString g_sect_name_dwarf_debug_loc_dwo (".debug_loc.dwo");
             static ConstString g_sect_name_dwarf_debug_str_dwo (".debug_str.dwo");
             static ConstString g_sect_name_dwarf_debug_str_offsets_dwo (".debug_str_offsets.dwo");
             static ConstString g_sect_name_eh_frame (".eh_frame");
             static ConstString g_sect_name_arm_exidx (".ARM.exidx");
             static ConstString g_sect_name_arm_extab (".ARM.extab");
             static ConstString g_sect_name_go_symtab (".gosymtab");
 
if (!m_sections_ap.get() && ParseSectionHeaders())
             else if (name == g_sect_name_dwarf_debug_abbrev)          sect_type = eSectionTypeDWARFDebugAbbrev;
             else if (name == g_sect_name_dwarf_debug_addr)            sect_type = eSectionTypeDWARFDebugAddr;
             else if (name == g_sect_name_dwarf_debug_aranges)         sect_type = eSectionTypeDWARFDebugAranges;
             else if (name == g_sect_name_dwarf_debug_frame)           sect_type = eSectionTypeDWARFDebugFrame;
             else if (name == g_sect_name_dwarf_debug_info)            sect_type = eSectionTypeDWARFDebugInfo;
             else if (name == g_sect_name_dwarf_debug_line)            sect_type = eSectionTypeDWARFDebugLine;
             else if (name == g_sect_name_dwarf_debug_loc)             sect_type = eSectionTypeDWARFDebugLoc;
             else if (name == g_sect_name_dwarf_debug_macinfo)         sect_type = eSectionTypeDWARFDebugMacInfo;
+            else if (name == g_sect_name_dwarf_debug_macro)           sect_type = eSectionTypeDWARFDebugMacro;
             else if (name == g_sect_name_dwarf_debug_pubnames)        sect_type = eSectionTypeDWARFDebugPubNames;
             else if (name == g_sect_name_dwarf_debug_pubtypes)        sect_type = eSectionTypeDWARFDebugPubTypes;
             else if (name == g_sect_name_dwarf_debug_ranges)          sect_type = eSectionTypeDWARFDebugRanges;
             else if (name == g_sect_name_dwarf_debug_str)             sect_type = eSectionTypeDWARFDebugStr;
             else if (name == g_sect_name_dwarf_debug_str_offsets)     sect_type = eSectionTypeDWARFDebugStrOffsets;
             else if (name == g_sect_name_dwarf_debug_abbrev_dwo)      sect_type = eSectionTypeDWARFDebugAbbrev;
             else if (name == g_sect_name_dwarf_debug_info_dwo)        sect_type = eSectionTypeDWARFDebugInfo;
             else if (name == g_sect_name_dwarf_debug_line_dwo)        sect_type = eSectionTypeDWARFDebugLine;
+            else if (name == g_sect_name_dwarf_debug_macro_dwo)       sect_type = eSectionTypeDWARFDebugMacro;
             else if (name == g_sect_name_dwarf_debug_loc_dwo)         sect_type = eSectionTypeDWARFDebugLoc;
             else if (name == g_sect_name_dwarf_debug_str_dwo)         sect_type = eSectionTypeDWARFDebugStr;
             else if (name == g_sect_name_dwarf_debug_str_offsets_dwo) sect_type = eSectionTypeDWARFDebugStrOffsets;
             else if (name == g_sect_name_eh_frame)                    sect_type = eSectionTypeEHFrame;
             else if (name == g_sect_name_arm_exidx)                   sect_type = eSectionTypeARMexidx;
             else if (name == g_sect_name_arm_extab)                   sect_type = eSectionTypeARMextab;
             else if (name == g_sect_name_go_symtab)                   sect_type = eSectionTypeGoSymtab;
 

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (symtab)
                     case eSectionTypeDWARFDebugAbbrev:
                     case eSectionTypeDWARFDebugAddr:
                     case eSectionTypeDWARFDebugAranges:
                     case eSectionTypeDWARFDebugFrame:
                     case eSectionTypeDWARFDebugInfo:
                     case eSectionTypeDWARFDebugLine:
                     case eSectionTypeDWARFDebugLoc:
                     case eSectionTypeDWARFDebugMacInfo:
+                    case eSectionTypeDWARFDebugMacro:
                     case eSectionTypeDWARFDebugPubNames:
                     case eSectionTypeDWARFDebugPubTypes:
                     case eSectionTypeDWARFDebugRanges:
                     case eSectionTypeDWARFDebugStr:
                     case eSectionTypeDWARFDebugStrOffsets:
                     case eSectionTypeDWARFAppleNames:
                     case eSectionTypeDWARFAppleTypes:
                     case eSectionTypeDWARFAppleNamespaces:

source/Plugins/SymbolFile/DWARF/CMakeLists.txt

 add_lldb_library(lldbPluginSymbolFileDWARF
   DIERef.cpp
   DWARFAbbreviationDeclaration.cpp
   DWARFASTParserClang.cpp
   DWARFASTParserGo.cpp
   DWARFAttribute.cpp
   DWARFCompileUnit.cpp
   DWARFDataExtractor.cpp
   DWARFDebugAbbrev.cpp
   DWARFDebugAranges.cpp
   DWARFDebugArangeSet.cpp
   DWARFDebugInfo.cpp
   DWARFDebugInfoEntry.cpp
   DWARFDebugLine.cpp
+  DWARFDebugMacro.cpp
   DWARFDebugMacinfo.cpp
   DWARFDebugMacinfoEntry.cpp
   DWARFDebugPubnames.cpp
   DWARFDebugPubnamesSet.cpp
   DWARFDebugRanges.cpp
   DWARFDeclContext.cpp
   DWARFDefines.cpp
   DWARFDIE.cpp

source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.h

+//===-- DWARFDebugMacro.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SymbolFileDWARF_DWARFDebugMacro_h_
+#define SymbolFileDWARF_DWARFDebugMacro_h_
+
+#include <map>
+
+#include "lldb/lldb-types.h"
+#include "lldb/Core/dwarf.h"
+#include "lldb/Symbol/DebugMacros.h"
+
+namespace lldb_private
+{
+
+class DWARFDataExtractor;
+
+} // namespace lldb_private
+
+class SymbolFileDWARF;
+
+class DWARFDebugMacroHeader
+{
+public:
+    enum HeaderFlagMask
+    {
+        OFFSET_SIZE_MASK = 0x1,
+        DEBUG_LINE_OFFSET_MASK = 0x2,
+        OPCODE_OPERANDS_TABLE_MASK = 0x4
+    };
+
+    static DWARFDebugMacroHeader
+    ParseHeader(const lldb_private::DWARFDataExtractor &debug_macro_data, lldb::offset_t *offset);
+
+    bool
+    OffsetIs64Bit() const
+    {
+        return m_offset_is_64_bit;
+    }
+
+private:
+    static void
+    SkipOperandTable(const lldb_private::DWARFDataExtractor &debug_macro_data, lldb::offset_t *offset);
+
+    uint16_t m_version;
+    bool m_offset_is_64_bit;
+    uint64_t m_debug_line_offset;
+};
+
+class DWARFDebugMacroEntry
+{
+public:
+    static void
+    ReadMacroEntries(const lldb_private::DWARFDataExtractor &debug_macro_data,
+                     const lldb_private::DWARFDataExtractor &debug_str_data,
+                     const bool offset_is_64_bit,
+                     lldb::offset_t *sect_offset,
+                     SymbolFileDWARF *sym_file_dwarf,
+                     lldb_private::DebugMacrosSP &debug_macros_sp);
+};
+
+#endif // SymbolFileDWARF_DWARFDebugMacro_h_

source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp

+//===-- DWARFDebugMacro.cpp -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DWARFDebugMacro.h"
+#include "SymbolFileDWARF.h"
+
+#include "lldb/Symbol/DebugMacros.h"
+
+#include "DWARFDataExtractor.h"
+
+using namespace lldb_private;
+
+DWARFDebugMacroHeader
+DWARFDebugMacroHeader::ParseHeader(const DWARFDataExtractor &debug_macro_data, lldb::offset_t *offset)
+{
+    DWARFDebugMacroHeader header;
+
+    // Skip over the version field in header.
+    header.m_version = debug_macro_data.GetU16(offset);
+
+    uint8_t flags = debug_macro_data.GetU8(offset);
+    header.m_offset_is_64_bit = flags & OFFSET_SIZE_MASK ? true : false;
+
+    if (flags & DEBUG_LINE_OFFSET_MASK)
+    {
+        if (header.m_offset_is_64_bit)
+            header.m_debug_line_offset = debug_macro_data.GetU64(offset);
+        else
+            header.m_debug_line_offset = debug_macro_data.GetU32(offset);
+    }
+
+    // Skip over the operands table if it is present.
+    if (flags & OPCODE_OPERANDS_TABLE_MASK)
+        SkipOperandTable(debug_macro_data, offset);
+
+    return header;
+}
+
+void
+DWARFDebugMacroHeader::SkipOperandTable(const DWARFDataExtractor &debug_macro_data, lldb::offset_t *offset)
+{
+    uint8_t entry_count = debug_macro_data.GetU8(offset);
+    for (uint8_t i = 0; i < entry_count; i++)
+    {
+        // Skip over the opcode number.
+        debug_macro_data.GetU8(offset);
+
+        uint64_t operand_count = debug_macro_data.GetULEB128(offset);
+
+        for (uint64_t j = 0; j < operand_count; j++)
+        {
+            // Skip over the operand form
+            debug_macro_data.GetU8(offset);
+        }
+    }
+}
+
+void
+DWARFDebugMacroEntry::ReadMacroEntries(const DWARFDataExtractor &debug_macro_data,
+                                       const DWARFDataExtractor &debug_str_data,
+                                       const bool offset_is_64_bit,
+                                       lldb::offset_t *offset,
+                                       SymbolFileDWARF *sym_file_dwarf,
+                                       DebugMacrosSP &debug_macros_sp)
+{
+    llvm::dwarf::MacroEntryType type = static_cast<llvm::dwarf::MacroEntryType>(debug_macro_data.GetU8(offset));
+    while (type != 0)
+    {
+        lldb::offset_t new_offset = 0, str_offset = 0;
+        uint32_t line = 0;
+        const char *macro_str = nullptr;
+        uint32_t debug_line_file_idx = 0;
+
+        switch (type)
+        {
+            case DW_MACRO_define:
+            case DW_MACRO_undef:
+                line = debug_macro_data.GetULEB128(offset);
+                macro_str = debug_macro_data.GetCStr(offset);
+                if (type == DW_MACRO_define)
+                    debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateDefineEntry(line, macro_str));
+                else
+                    debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateUndefEntry(line, macro_str));
+                break;
+            case DW_MACRO_define_indirect:
+            case DW_MACRO_undef_indirect:
+                line = debug_macro_data.GetULEB128(offset);
+                if (offset_is_64_bit)
+                    str_offset = debug_macro_data.GetU64(offset);
+                else
+                    str_offset = debug_macro_data.GetU32(offset);
+                macro_str = debug_str_data.GetCStr(&str_offset);
+                if (type == DW_MACRO_define_indirect)
+                    debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateDefineEntry(line, macro_str));
+                else
+                    debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateUndefEntry(line, macro_str));
+                break;
+            case DW_MACRO_start_file:
+                line = debug_macro_data.GetULEB128(offset);
+                debug_line_file_idx = debug_macro_data.GetULEB128(offset);
+                debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateStartFileEntry(line, debug_line_file_idx));
+                break;
+            case DW_MACRO_end_file:
+                // This operation has no operands.
+                debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateEndFileEntry());
+                break;
+            case DW_MACRO_transparent_include:
+                if (offset_is_64_bit)
+                    new_offset = debug_macro_data.GetU64(offset);
+                else
+                    new_offset = debug_macro_data.GetU32(offset);
+                debug_macros_sp->AddMacroEntry(
+                    DebugMacroEntry::CreateIndirectEntry(sym_file_dwarf->ParseDebugMacros(&new_offset)));
+                break;
+            default:
+                // TODO: Add support for other standard operations.
+                // TODO: Provide mechanism to hook handling of non-standard/extension operands.
+                return;
+        }
+        type = static_cast<llvm::dwarf::MacroEntryType>(debug_macro_data.GetU8(offset));
+    }
+}

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 #define SymbolFileDWARF_SymbolFileDWARF_h_
 
 // C Includes
 // C++ Includes
 #include <list>
 #include <map>
 #include <mutex>
 #include <set>
+#include <unordered_map>
 #include <vector>
 
 // Other libraries and framework includes
 #include "llvm/ADT/DenseMap.h"
 
 #include "lldb/lldb-private.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Core/Flags.h"
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Expression/DWARFExpression.h"
+#include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 
 // Project includes
 #include "DWARFDefines.h"
 #include "DWARFDataExtractor.h"
 #include "HashedNameToDIE.h"
 #include "NameToDIE.h"
public:
 
     size_t
     ParseCompileUnitFunctions (const lldb_private::SymbolContext& sc) override;
 
     bool
     ParseCompileUnitLineTable (const lldb_private::SymbolContext& sc) override;
 
     bool
+    ParseCompileUnitDebugMacros (const lldb_private::SymbolContext& sc) override;
+
+    bool
     ParseCompileUnitSupportFiles (const lldb_private::SymbolContext& sc,
                                   lldb_private::FileSpecList& support_files) override;
 
     bool
     ParseImportedModules (const lldb_private::SymbolContext &sc,
                           std::vector<lldb_private::ConstString> &imported_modules) override;
 
     size_t
public:
     GetPluginVersion() override;
 
     const lldb_private::DWARFDataExtractor&     get_debug_abbrev_data ();
     const lldb_private::DWARFDataExtractor&     get_debug_addr_data ();
     const lldb_private::DWARFDataExtractor&     get_debug_aranges_data ();
     const lldb_private::DWARFDataExtractor&     get_debug_frame_data ();
     const lldb_private::DWARFDataExtractor&     get_debug_info_data ();
     const lldb_private::DWARFDataExtractor&     get_debug_line_data ();
+    const lldb_private::DWARFDataExtractor&     get_debug_macro_data ();
     const lldb_private::DWARFDataExtractor&     get_debug_loc_data ();
     const lldb_private::DWARFDataExtractor&     get_debug_ranges_data ();
     const lldb_private::DWARFDataExtractor&     get_debug_str_data ();
     const lldb_private::DWARFDataExtractor&     get_debug_str_offsets_data ();
     const lldb_private::DWARFDataExtractor&     get_apple_names_data ();
     const lldb_private::DWARFDataExtractor&     get_apple_types_data ();
     const lldb_private::DWARFDataExtractor&     get_apple_namespaces_data ();
     const lldb_private::DWARFDataExtractor&     get_apple_objc_data ();
public:
 
     size_t
     GetObjCMethodDIEOffsets (lldb_private::ConstString class_name,
                              DIEArray &method_die_offsets);
 
     bool
     Supports_DW_AT_APPLE_objc_complete_type (DWARFCompileUnit *cu);
 
+    lldb_private::DebugMacrosSP
+    ParseDebugMacros(lldb::offset_t *offset);
+
     static DWARFDIE
     GetParentSymbolContextDIE(const DWARFDIE &die);
 
     virtual lldb::CompUnitSP
     ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx);
 
     virtual lldb_private::DWARFExpression::LocationListFormat
     GetLocationListFormat() const;
protected:
     lldb_private::DWARFDataExtractor      m_dwarf_data;
 
     DWARFDataSegment                      m_data_debug_abbrev;
     DWARFDataSegment                      m_data_debug_addr;
     DWARFDataSegment                      m_data_debug_aranges;
     DWARFDataSegment                      m_data_debug_frame;
     DWARFDataSegment                      m_data_debug_info;
     DWARFDataSegment                      m_data_debug_line;
+    DWARFDataSegment                      m_data_debug_macro;
     DWARFDataSegment                      m_data_debug_loc;
     DWARFDataSegment                      m_data_debug_ranges;
     DWARFDataSegment                      m_data_debug_str;
     DWARFDataSegment                      m_data_debug_str_offsets;
     DWARFDataSegment                      m_data_apple_names;
     DWARFDataSegment                      m_data_apple_types;
     DWARFDataSegment                      m_data_apple_namespaces;
     DWARFDataSegment                      m_data_apple_objc;
 
     // The unique pointer items below are generated on demand if and when someone accesses
     // them through a non const version of this class.
     std::unique_ptr<DWARFDebugAbbrev>     m_abbr;
     std::unique_ptr<DWARFDebugInfo>       m_info;
     std::unique_ptr<DWARFDebugLine>       m_line;
     std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_names_ap;
     std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_types_ap;
     std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_namespaces_ap;
     std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_objc_ap;
     std::unique_ptr<GlobalVariableMap>  m_global_aranges_ap;
+
+    typedef std::unordered_map<lldb::offset_t, lldb_private::DebugMacrosSP> DebugMacrosMap;
+    DebugMacrosMap m_debug_macros_map;
+
     ExternalTypeModuleMap               m_external_type_modules;
     NameToDIE                           m_function_basename_index;  // All concrete functions
     NameToDIE                           m_function_fullname_index;  // All concrete functions
     NameToDIE                           m_function_method_index;    // All inlined functions
     NameToDIE                           m_function_selector_index;  // All method names for functions of classes
     NameToDIE                           m_objc_class_selectors_index; // Given a class name, find all selectors for the class
     NameToDIE                           m_global_index;             // Global and static variables
     NameToDIE                           m_type_index;               // All type DIE offsets

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #include "lldb/Interpreter/OptionValueProperties.h"
 
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
+#include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Symbol/TypeMap.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 
 #include "lldb/Target/Language.h"
 
 #include "lldb/Utility/TaskPool.h"
 
 #include "DWARFASTParser.h"
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugLine.h"
+#include "DWARFDebugMacro.h"
 #include "DWARFDebugPubnames.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFDIECollection.h"
 #include "DWARFFormValue.h"
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDebugMap.h"
SymbolFileDWARF::SymbolFileDWARF(ObjectFile* objfile) :
     UserID (0),  // Used by SymbolFileDWARFDebugMap to when this class parses .o files to contain the .o file index/ID
     m_debug_map_module_wp (),
     m_debug_map_symfile (NULL),
     m_data_debug_abbrev (),
     m_data_debug_aranges (),
     m_data_debug_frame (),
     m_data_debug_info (),
     m_data_debug_line (),
+    m_data_debug_macro (),
     m_data_debug_loc (),
     m_data_debug_ranges (),
     m_data_debug_str (),
     m_data_apple_names (),
     m_data_apple_types (),
     m_data_apple_namespaces (),
     m_abbr(),
     m_info(),

 
 const DWARFDataExtractor&
 SymbolFileDWARF::get_debug_line_data()
 {
     return GetCachedSectionData (eSectionTypeDWARFDebugLine, m_data_debug_line);
 }
 
 const DWARFDataExtractor&
+SymbolFileDWARF::get_debug_macro_data()
+{
+    return GetCachedSectionData (eSectionTypeDWARFDebugMacro, m_data_debug_macro);
+}
+
+const DWARFDataExtractor&
 SymbolFileDWARF::get_debug_loc_data()
 {
     return GetCachedSectionData (eSectionTypeDWARFDebugLoc, m_data_debug_loc);
 }
 
 const DWARFDataExtractor&
 SymbolFileDWARF::get_debug_ranges_data()
 {
if (dwarf_cu)
                     }
                 }
             }
         }
     }
     return false;
 }
 
+lldb_private::DebugMacrosSP
+SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset)
+{
+    auto iter = m_debug_macros_map.find(*offset);
+    if (iter != m_debug_macros_map.end())
+        return iter->second;
+
+    const DWARFDataExtractor &debug_macro_data = get_debug_macro_data();
+    if (debug_macro_data.GetByteSize() == 0)
+        return DebugMacrosSP();
+
+    lldb_private::DebugMacrosSP debug_macros_sp(new lldb_private::DebugMacros());
+    m_debug_macros_map[*offset] = debug_macros_sp;
+
+    const DWARFDebugMacroHeader &header = DWARFDebugMacroHeader::ParseHeader(debug_macro_data, offset);
+    DWARFDebugMacroEntry::ReadMacroEntries(
+        debug_macro_data, get_debug_str_data(), header.OffsetIs64Bit(), offset, this, debug_macros_sp);
+
+    return debug_macros_sp;
+}
+
+bool
+SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext& sc)
+{
+    assert (sc.comp_unit);
+
+    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+    if (dwarf_cu == nullptr)
+        return false;
+
+    const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();
+    if (!dwarf_cu_die)
+        return false;
+
+    lldb::offset_t sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET);
+    if (sect_offset == DW_INVALID_OFFSET)
+        sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros, DW_INVALID_OFFSET);
+    if (sect_offset == DW_INVALID_OFFSET)
+        return false;
+
+    sc.comp_unit->SetDebugMacros(ParseDebugMacros(&sect_offset));
+
+    return true;
+}
+
 size_t
 SymbolFileDWARF::ParseFunctionBlocks (const SymbolContext& sc,
                                       Block *parent_block,
                                       const DWARFDIE &orig_die,
                                       addr_t subprogram_low_pc,
                                       uint32_t depth)
 {
     size_t blocks_added = 0;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
     // Compile Unit function calls
     //------------------------------------------------------------------
     uint32_t        GetNumCompileUnits () override;
     lldb::CompUnitSP ParseCompileUnitAtIndex (uint32_t index) override;
 
     lldb::LanguageType ParseCompileUnitLanguage (const lldb_private::SymbolContext& sc) override;
     size_t          ParseCompileUnitFunctions (const lldb_private::SymbolContext& sc) override;
     bool            ParseCompileUnitLineTable (const lldb_private::SymbolContext& sc) override;
+    bool            ParseCompileUnitDebugMacros (const lldb_private::SymbolContext& sc) override;
     bool            ParseCompileUnitSupportFiles (const lldb_private::SymbolContext& sc, lldb_private::FileSpecList &support_files) override;
     bool            ParseImportedModules (const lldb_private::SymbolContext &sc, std::vector<lldb_private::ConstString> &imported_modules) override;
     size_t          ParseFunctionBlocks (const lldb_private::SymbolContext& sc) override;
     size_t          ParseTypes (const lldb_private::SymbolContext& sc) override;
     size_t          ParseVariablesForContext (const lldb_private::SymbolContext& sc) override;
 
     lldb_private::Type* ResolveTypeUID (lldb::user_id_t type_uid) override;
     lldb_private::CompilerDeclContext GetDeclContextForUID (lldb::user_id_t uid) override;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

 {
     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
     if (oso_dwarf)
         return oso_dwarf->ParseCompileUnitLineTable (sc);
     return false;
 }
 
 bool
+SymbolFileDWARFDebugMap::ParseCompileUnitDebugMacros (const SymbolContext& sc)
+{
+    SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
+    if (oso_dwarf)
+        return oso_dwarf->ParseCompileUnitDebugMacros (sc);
+    return false;
+}
+
+bool
 SymbolFileDWARFDebugMap::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList &support_files)
 {
     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
     if (oso_dwarf)
         return oso_dwarf->ParseCompileUnitSupportFiles (sc, support_files);
     return false;
 }
 

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

public:
 
     size_t
     ParseCompileUnitFunctions(const lldb_private::SymbolContext& sc) override;
 
     bool
     ParseCompileUnitLineTable(const lldb_private::SymbolContext& sc) override;
 
     bool
+    ParseCompileUnitDebugMacros(const lldb_private::SymbolContext& sc) override;
+
+    bool
     ParseCompileUnitSupportFiles(const lldb_private::SymbolContext& sc,
                                  lldb_private::FileSpecList &support_files) override;
     
     bool
     ParseImportedModules(const lldb_private::SymbolContext &sc,
                          std::vector<lldb_private::ConstString> &imported_modules) override;
 
     size_t

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

 
 bool
 SymbolFileSymtab::ParseCompileUnitLineTable (const SymbolContext &sc)
 {
     return false;
 }
 
 bool
+SymbolFileSymtab::ParseCompileUnitDebugMacros (const SymbolContext &sc)
+{
+    return false;
+}
+
+bool
 SymbolFileSymtab::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList &support_files)
 {
     return false;
 }
 
 bool
 SymbolFileSymtab::ParseImportedModules (const SymbolContext &sc, std::vector<ConstString> &imported_modules)
 {

source/Symbol/CMakeLists.txt

 add_lldb_library(lldbSymbol
   ArmUnwindInfo.cpp
   Block.cpp
   ClangASTContext.cpp
   ClangASTImporter.cpp
   ClangExternalASTSourceCallbacks.cpp
   ClangExternalASTSourceCommon.cpp
   CompilerDecl.cpp
   CompilerDeclContext.cpp
   CompilerType.cpp
   CompileUnit.cpp
   CompactUnwindInfo.cpp
+  DebugMacros.cpp
   Declaration.cpp
   DWARFCallFrameInfo.cpp
   Function.cpp
   FuncUnwinders.cpp
   GoASTContext.cpp
   LineEntry.cpp
   LineTable.cpp
   ObjectFile.cpp

source/Symbol/CompileUnit.cpp

 {
     if (line_table == nullptr)
         m_flags.Clear(flagsParsedLineTable);
     else
         m_flags.Set(flagsParsedLineTable);
     m_line_table_ap.reset(line_table);
 }
 
+DebugMacros*
+CompileUnit::GetDebugMacros()
+{
+    if (m_debug_macros_sp.get() == nullptr)
+    {
+        if (m_flags.IsClear(flagsParsedDebugMacros))
+        {
+            m_flags.Set(flagsParsedDebugMacros);
+            SymbolVendor* symbol_vendor = GetModule()->GetSymbolVendor();
+            if (symbol_vendor)
+            {
+                SymbolContext sc;
+                CalculateSymbolContext(&sc);
+                symbol_vendor->ParseCompileUnitDebugMacros(sc);
+            }
+        }
+    }
+
+    return m_debug_macros_sp.get();
+}
+
+void
+CompileUnit::SetDebugMacros(const DebugMacrosSP &debug_macros_sp)
+{
+    if (debug_macros_sp.get() == nullptr)
+        m_flags.Clear(flagsParsedDebugMacros);
+    else
+        m_flags.Set(flagsParsedDebugMacros);
+    m_debug_macros_sp = debug_macros_sp;
+}
+
 VariableListSP
 CompileUnit::GetVariableList(bool can_create)
 {
     if (m_variables.get() == nullptr && can_create)
     {
         SymbolContext sc;
         CalculateSymbolContext(&sc);
         assert(sc.module_sp);

source/Symbol/DebugMacros.cpp

+//===-- DebugMacros.cpp -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Symbol/DebugMacros.h"
+
+#include "lldb/Symbol/CompileUnit.h"
+
+using namespace lldb_private;
+
+DebugMacroEntry::DebugMacroEntry(EntryType type,
+                                 uint32_t line,
+                                 uint32_t debug_line_file_idx,
+                                 const char *str)
+    : m_type(type),
+      m_line(line),
+      m_debug_line_file_idx(debug_line_file_idx),
+      m_str(str)
+{ }
+
+DebugMacroEntry::DebugMacroEntry(EntryType type,
+                                 const DebugMacrosSP &debug_macros_sp)
+    : m_type(type), m_line(0), m_debug_line_file_idx(0), m_debug_macros_sp(debug_macros_sp)
+{ }
+
+const FileSpec&
+DebugMacroEntry::GetFileSpec(CompileUnit *comp_unit) const
+{
+    return comp_unit->GetSupportFiles().GetFileSpecAtIndex(m_debug_line_file_idx);
+}
+
+DebugMacroEntry
+DebugMacroEntry::CreateDefineEntry(uint32_t line, const char *str)
+{
+    return DebugMacroEntry(DebugMacroEntry::DEFINE, line, 0, str);
+}
+
+DebugMacroEntry
+DebugMacroEntry::CreateUndefEntry(uint32_t line, const char *str)
+{
+    return DebugMacroEntry(DebugMacroEntry::UNDEF, line, 0, str);
+}
+
+DebugMacroEntry
+DebugMacroEntry::CreateStartFileEntry(uint32_t line, uint32_t debug_line_file_idx)
+{
+    return DebugMacroEntry(DebugMacroEntry::START_FILE, line, debug_line_file_idx, nullptr);
+}
+
+DebugMacroEntry
+DebugMacroEntry::CreateEndFileEntry()
+{
+    return DebugMacroEntry(DebugMacroEntry::END_FILE, 0, 0, nullptr);
+}
+
+DebugMacroEntry
+DebugMacroEntry::CreateIndirectEntry(const DebugMacrosSP &debug_macros_sp)
+{
+    return DebugMacroEntry(DebugMacroEntry::INDIRECT, debug_macros_sp);
+}

source/Symbol/ObjectFile.cpp

if (symtab)
                     case eSectionTypeDWARFDebugAbbrev:
                     case eSectionTypeDWARFDebugAddr:
                     case eSectionTypeDWARFDebugAranges:
                     case eSectionTypeDWARFDebugFrame:
                     case eSectionTypeDWARFDebugInfo:
                     case eSectionTypeDWARFDebugLine:
                     case eSectionTypeDWARFDebugLoc:
                     case eSectionTypeDWARFDebugMacInfo:
+                    case eSectionTypeDWARFDebugMacro:
                     case eSectionTypeDWARFDebugPubNames:
                     case eSectionTypeDWARFDebugPubTypes:
                     case eSectionTypeDWARFDebugRanges:
                     case eSectionTypeDWARFDebugStr:
                     case eSectionTypeDWARFDebugStrOffsets:
                     case eSectionTypeDWARFAppleNames:
                     case eSectionTypeDWARFAppleTypes:
                     case eSectionTypeDWARFAppleNamespaces:

source/Symbol/SymbolVendor.cpp

if (module_sp)
         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ParseCompileUnitLineTable(sc);
     }
     return false;
 }
 
 bool
+SymbolVendor::ParseCompileUnitDebugMacros (const SymbolContext &sc)
+{
+    ModuleSP module_sp(GetModule());
+    if (module_sp)
+    {
+        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        if (m_sym_file_ap.get())
+            return m_sym_file_ap->ParseCompileUnitDebugMacros(sc);
+    }
+    return false;
+}
+bool
 SymbolVendor::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files)
 {
     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ParseCompileUnitSupportFiles(sc, support_files);

source/Utility/ConvertEnum.cpp

switch (sect_type)
         case eSectionTypeDWARFDebugInfo:
             return "dwarf-info";
         case eSectionTypeDWARFDebugLine:
             return "dwarf-line";
         case eSectionTypeDWARFDebugLoc:
             return "dwarf-loc";
         case eSectionTypeDWARFDebugMacInfo:
             return "dwarf-macinfo";
+        case eSectionTypeDWARFDebugMacro:
+            return "dwarf-macro";
         case eSectionTypeDWARFDebugPubNames:
             return "dwarf-pubnames";
         case eSectionTypeDWARFDebugPubTypes:
             return "dwarf-pubtypes";
         case eSectionTypeDWARFDebugRanges:
             return "dwarf-ranges";
         case eSectionTypeDWARFDebugStr:
             return "dwarf-str";