Search variables based on clang::DeclContext and clang::Decl tree

[paulherman]

Summary

SymbolFileDWARF now creates VarDecl and BlockDecl and adds them to the Decl tree. Then, in ClangExpressionDeclMap it uses the Decl tree to search for a variable. This fixes lots of variable scoping problems.

[paulherman]

Search variables based on clang::DeclContext and clang::Decl tree

[paulherman]

Search variables based on clang::DeclContext and clang::Decl tree

[paulherman]

Search variables based on clang::DeclContext and clang::Decl tree

[paulherman]

Search variables based on clang::DeclContext and clang::Decl tree

[jingham]

Sean should take a look at this as well, since it directly affects how the expression parser lookup works.

[paulherman]

Search variables based on clang::DeclContext and clang::Decl tree

Rebased the patch.

[paulherman]

Ping.

[clayborg]

So a few themes I would like to get fixed:

• Don't parse everything in DWARF in case we ever need it (like parsing all namespaces and their contained variables, parse and cache all Block CompilerDeclContext within Block, etc), but do this lazily.
• Add functionality to the abstract CompilerDeclContext to be able to find things within it. If we have namespace "a" with 1000000 variables inside, we should only parse the variables we need and we should ask the CompilerDeclContext to find things for us instead of parsing all 1000000 variables and then finding "b" in that list of 1000000 variables. We should ask the CompilerDeclContext:

CompilerDecl var_decl = decl_ctx.FindVariable("a");
CompilerDeclList decl_list = decl_ctx.FindDecls("b");

• Parse things lazily as we need them and try not to store them in objects if we don't need to.

include/lldb/Symbol/Block.h

362–366 ↗

(On Diff #34352)

Why did you add this function? See the function just above it? Why did you not use that one? This should be removed and it should be lazily determined by Block::GetDeclContext(). The current implementation should be all you need.

368–372 ↗

(On Diff #34352)

Remove this. Not needed. We should calculate the decl context in Block::GetDeclContext() as needed. No need to store this in the block permanently.

492 ↗

(On Diff #34352)

Remove this and let Block::GetDeclContext() create one for you each time. No need to permanently store this in a block instance.

include/lldb/Symbol/ClangASTContext.h

1089–1177

Should probably move these to the .cpp file.

include/lldb/Symbol/Variable.h

177–181

Is a variable a really a clang::DeclContext? This seems wrong. We might need a CompilerDecl class, but this seems wrong to put this in a CompilerDeclContext because a clang::VarDecl isn't a clang::DeclContext, it is a clang::Decl. Am I wrong?

183–187

Can we get rid of this and lazily init it in GetVarDecl() with code like:

CompilerDeclContext 
GetVarDecl ()
{
    if (!m_var_decl)
    {
         SymbolFile *symfile = ...;
         if (symfile)
             m_var_decl = symfile->GetDeclContext();
    }
    return m_var_decl;
}

source/Expression/ClangExpressionDeclMap.cpp

1359

Use llvm casting:

ClangASTContext *ast_context =  llvm::dyn_cast_or_null<ClangASTContext>(compiler_decl_context.GetTypeSystem());

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

1331–1341

Let the blocks parse these lazily as needed. We don't need to compute the CompilerDeclContext for any block unless we ask it to. The "Block::GetDeclContext()" call already exists and "does the right thing". No need for this.

3724–3726

We shouldn't do this all the time. This will cause performance issues. If something needs a namespace, it should call through the existing SymbolFile virtual function:

lldb_private::CompilerDeclContext
FindNamespace (const lldb_private::SymbolContext& sc,
               const lldb_private::ConstString &name,
               const lldb_private::CompilerDeclContext *parent_decl_ctx) override;

If you need to lookup namespace "b" that is in namespace "b" (a::b) you would call the above function with: "a" as the name first and a CompilerDeclContext for the translation unit (we might need to add a function to lldb_private::CompileUnit:

class CompileUnit
{
    CompilerDeclContext
    GetDeclContext ();
}

And it will lazily compute its compiler decl context and return it:

CompilerDeclContext cu_decl_ctx = sc.comp_unit->GetDeclContext();

CompilerDeclContext a_decl_ctx = symfile->FindNamespace(sc, ConstString("a"), &cu_decl_ctx);
if (a_decl_ctx)
{
    CompilerDeclContext b_decl_ctx = symfile->FindNamespace(sc, ConstString("b"), &a_decl_ctx);
}

We need to avoid adding code that parses all namespaces within a compile unit just because we might need the information later.

3731–3792

So no clang:: code should exist in SymbolFileDWARF. Any code that uses "clang::" (which is a recent change) needs to be moved into DWARFASTParserClang for clang specific things.

I like to see abilities added to CompilerDeclContext that can discover the variable declarations inside a specific CompilerDeclContext.

Lets say we have:

namespace a 
{
    int aa;
}

We should be able to get a CompilerDeclContext for namespace "a" and then ask the "a_decl_ctx" to find a variable named "aa". This way we avoid having to parse all namespaces and all variables within that namespace (which could be a lot of variables). This means we would need to ask a CompilerDeclContext something like:

CompilerDeclContext a_decl_ctx = ...;
if (a_decl_ctx)
{
    CompilerDecl var_decl = a_decl_ctx.FindVariable("aa");

Under the covers the CompilerDeclContext would need to call back into its symbol file (the TypeSystem inside the CompilerDeclContext has a link back to its SymbolFile).

4106–4121

I would like to avoid any of this kind of "parse a bunch of information 99% of the debugger will never use and store it permanently in case it ever gets used" kind of thing and discover variables through CompilerDeclContext as mentioned above.

4278–4279

I would like to avoid any of this kind of "parse a bunch of information 99% of the debugger will never use and store it permanently in case it ever gets used" kind of thing and discover variables through CompilerDeclContext as mentioned above.

[paulherman]

I agree with most of your comments and will fix them.

One thing I noticed is that Block::GetDeclContext() does not do the right thing (see inline comment).

About creating a CompilerDecl class, I agree with you. I used CompilerDeclContext since it was just a void* and it was convenient. Do you think that the FindVariable method should be in ClangASTContext since there is the need to actually interpret the CompilerDeclContext according to clang rules?

Regarding ParseImportedNamespace, it also deals with "using NS::var" directives. Is there a method similar to FindNamespace that I can use?

In SymbolFileDWARF::GetDeclContextDIEContainingDIE, is there a reason why DW_TAG_subprogram, DW_TAG_lexical_block, etc are not considered DeclContexts?

include/lldb/Symbol/Block.h

362–366 ↗

(On Diff #34352)

This function is needed as currently it returns the block of the function, not the block of the variable. See example below:

void function() 
{ // block 1 start
    ...
    { // block 2 start
        { // block 3 start
             // if we ask GetDeclContext() it returns the decl context of block 1 instead of block 2
        } // block 3 end
    } // block 2 end
} // block 1 end

[clayborg]

In D12658#243863, @paulherman wrote:

I agree with most of your comments and will fix them.

One thing I noticed is that Block::GetDeclContext() does not do the right thing (see inline comment).

Yep, we only ever needed the function decl context before this. We can rename Block::GetDeclContext() to be Block::GetFunctionDeclContext(), and fix all places that use it to use the new name. Then we modify Block::GetDeclContext() to do what you want it to do.

Also note that you don't want any methods on lldb_private classes to be named "GetClangXXX()" since these objects are abstracted from specific type systems, everything has to be generic and abstract.

About creating a CompilerDecl class, I agree with you. I used CompilerDeclContext since it was just a void* and it was convenient. Do you think that the FindVariable method should be in ClangASTContext since there is the need to actually interpret the CompilerDeclContext according to clang rules?

There will need to be a ClangASTContext::DeclContextXXXX call made, but this will need to be a TypeSystem virtual function that is overridden by ClangASTContext since it inherits from lldb_private::TypeSystem, but we should have an abstract call on CompilerDeclContext that initiates the search (CompilerDeclContext::FindVariable(...)), which in turn calls the "TypeSystem::DeclContextFindVariable(void *)". This then lets you get back to the clang specific ways of finding things.

We might want to go a bit more generic and make a function like:

class CompilerDeclContext
{
    CompilerDeclList FindDecls(const char *name);
}

Since we actually want to start returning more than 1 thing for a search by name and there might be a variable named "a" and a function named "a" in that decl context? Or two overloads of a function "a" in the decl context. So the question is: do we try and search for CompilerDecl objects in a CompilerDeclContext so we can find all things whose name is "a", or do we stick with more targeted things like "CompilerDeclContext::FindVariable(...)". If we go the FindVariable route, we can probably skip making the new CompilerDecl and CompilerDeclList classes and just return lldb::VariableSP or use a lldb_private::VariableList class.

Regarding ParseImportedNamespace, it also deals with "using NS::var" directives. Is there a method similar to FindNamespace that I can use?

We will need to add this to the CompilerDeclContext, TypeSystem and to the SymbolVendor/SymbolFile interfaces, all in abstract ways.

In SymbolFileDWARF::GetDeclContextDIEContainingDIE, is there a reason why DW_TAG_subprogram, DW_TAG_lexical_block, etc are not considered DeclContexts?

They currently are expecting it to ignore these things. The question is if that is correct or not. We will need to look at who is asking. At the very least we can add a bool that says "include_functions_blocks" and then include them in the response if true if there are too many places that are using this incorrectly. There are only 3 places that call this function so it wouldn't be hard to fix them up to do the right thing.

The other thing Sean Callanan and Jim Ingham wanted to pass along is we want lookups to happen in via the clang::ExternalASTSource function callbacks like:

namespace clang {
  class ExternalASTSource : public RefCountedBase<ExternalASTSource> {
    virtual bool
    FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name);
  }
}

I didn't look too closely at how your lookups were done, I mostly looked at the overall CompilerDeclContext and DWARF parsing aspect, but that is their preference. These lookups are always very targeted and say "inside the decl context 'DC', find "Name".

[paulherman]

I believe that the approach of CompilerDeclContext::FindDecls could be better. But then this kind of forces CompilerDeclContext to inherit CompilerDecl (a function is both a DeclContext and a Decl) and I believe that creating a class for each possible entity is an overkill.

I started looking at SymbolFileDWARF. In order to not have "clang::___", I believe that ParseVariableDIE and ParseFunctionBlocks should be moved to DWARFASTParser.

I don't really understand what Sean and Jim mean. I believe that ClangASTSource implements the interface ExternalASTSource and ClangExpressionDeclMap (which does the actual search) inherits ClangASTSource, so it should be already alright...?

EDIT
I worked on fixing some of the things. However, I always encounter the need to store a map from CompilerDecl to VariableSP since given a CompilerDeclContext (using the solution above) we can get the CompilerDecl. Where do you think it would be best to store this map? I thought about adding it to SymbolFileDWARF and adding a method VariableSP SymbolFileDWARF::GetVariableFromDecl(CompilerDecl decl).

The other solution idea I have is to use StackFrame::GetInScopeVariableList to get the list of variables and search through that list to see if a variable has a decl in the list returned by CompilerDeclContext::FindDeclsByName. This might be better since there already is a call to StackFrame::GetInScopeVariableList so that the variable dies are parsed (is there a better way of doing this?).

[paulherman]

[WIP] Search variables based on clang::DeclContext and clang::Decl tree

This revision fixes some of the comments. There are some things I'm not sure about. The problem is that at some point there will be the need to link decls with the object they represent (Function, Variable, CompileUnit, etc). Is the approach of getting the VariableSP from the TypeSystem the right one? Also, should ParseVariableDIE be moved to DWARFASTParser in order to create the decl there or should there only be a method CreateVariableDecl(VariableSP var)?

[paulherman]

Search variables based on clang::DeclContext and clang::Decl tree

I believe I fixed most of the comments. I removed the handling of using declarations for now and made the test an expected failure because of this. I think it would be better if the parsing of DW_TAG_imported_declaration and DW_TAG_imported_module is handled in a different diff because and let this one as is.

[tberghammer]

Generally looks good to me with a few minor comments, but please wait for a review from Greg or Jim.

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

3201

(nit): Please swap the order of the condition as ExtractFormValueAtIndex will be slower then the comparision

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

3883–3884

This check don't make sense here because dw_offset_t is 32bit and and UserIDMatches expects a 64bit value ant checks the symbol file id against the upper 32bit.

test/lang/cpp/nsimport/TestCppNsImport.py

19

Please add a bug number, or at least a short comment about why this test is XFAIL-ed

[paulherman]

Search variables based on clang::DeclContext and clang::Decl tree

I think this fixes the comments. It also adds a cache for clang::decl so that there is no memory wasted.

[clayborg]

In D12658#243953, @paulherman wrote:

I believe that the approach of CompilerDeclContext::FindDecls could be better. But then this kind of forces CompilerDeclContext to inherit CompilerDecl (a function is both a DeclContext and a Decl) and I believe that creating a class for each possible entity is an overkill.

I started looking at SymbolFileDWARF. In order to not have "clang::___", I believe that ParseVariableDIE and ParseFunctionBlocks should be moved to DWARFASTParser.

No they don't need to be. You just need to move the clang specific code into a function that is then passed through the TypeSystem interface. We don't need to make a CompilerDecl for a variable all the time, just when we ask the lldb_private::Variable class to get its CompilerDecl. So we could add method to Variable:

CompilerDecl
Variable::GetDecl();

It could always just call down to the symbol file and have the symbol file get the CompilerDecl for the variable. This would mean a new function on TypeSystem:

CompilerDecl
DeclGetDeclForVariable (const lldb::VariableSP &var_sp);

And that would eventually get routed down through the DWARFASTParser class...

I don't really understand what Sean and Jim mean. I believe that ClangASTSource implements the interface ExternalASTSource and ClangExpressionDeclMap (which does the actual search) inherits ClangASTSource, so it should be already alright...?

Yes the lookups currently happen like this and we should just be making function calls with any using directives to help fill in the results of this call.

EDIT
I worked on fixing some of the things. However, I always encounter the need to store a map from CompilerDecl to VariableSP since given a CompilerDeclContext (using the solution above) we can get the CompilerDecl. Where do you think it would be best to store this map? I thought about adding it to SymbolFileDWARF and adding a method VariableSP SymbolFileDWARF::GetVariableFromDecl(CompilerDecl decl).

If these are all abstract items, we can store any maps in TypeSystem itself.

The other solution idea I have is to use StackFrame::GetInScopeVariableList to get the list of variables and search through that list to see if a variable has a decl in the list returned by CompilerDeclContext::FindDeclsByName. This might be better since there already is a call to StackFrame::GetInScopeVariableList so that the variable dies are parsed (is there a better way of doing this?).

Yes, this would involve asking each VariableSP for its Decl using Variable::GetDecl() as mentioned above.

[clayborg]

In D12658#244710, @paulherman wrote:

[WIP] Search variables based on clang::DeclContext and clang::Decl tree

This revision fixes some of the comments. There are some things I'm not sure about. The problem is that at some point there will be the need to link decls with the object they represent (Function, Variable, CompileUnit, etc). Is the approach of getting the VariableSP from the TypeSystem the right one?

It is fine because each TypeSystem does have a link to its SymbolFile, so yes this will work.

Also, should ParseVariableDIE be moved to DWARFASTParser in order to create the decl there or should there only be a method CreateVariableDecl(VariableSP var)?

No. ParseVariableDIE shouldn't be making the CompilerDecl at all. We should do this only when we call the "Variable::GetDecl()". It should then route this through the TypeSystem from the variable type and ask the type system for the CompilerDecl. This will get routed to the SymbolFile and then to that will get routed to the DWARFASTParser (DWARFASTParserClang for this case).

[paulherman]

In D12658#245466, @clayborg wrote:

In D12658#244710, @paulherman wrote:

[WIP] Search variables based on clang::DeclContext and clang::Decl tree

This revision fixes some of the comments. There are some things I'm not sure about. The problem is that at some point there will be the need to link decls with the object they represent (Function, Variable, CompileUnit, etc). Is the approach of getting the VariableSP from the TypeSystem the right one?

It is fine because each TypeSystem does have a link to its SymbolFile, so yes this will work.

Also, should ParseVariableDIE be moved to DWARFASTParser in order to create the decl there or should there only be a method CreateVariableDecl(VariableSP var)?

No. ParseVariableDIE shouldn't be making the CompilerDecl at all. We should do this only when we call the "Variable::GetDecl()". It should then route this through the TypeSystem from the variable type and ask the type system for the CompilerDecl. This will get routed to the SymbolFile and then to that will get routed to the DWARFASTParser (DWARFASTParserClang for this case).

ParseVariableDIE does need at some point to get the CompilerDecl (but it gets it from Variable::GetDecl which calls DWARFASTParser) in order to link the Decl to the Variable. Is there a better solution to do this? Also, I think you're not looking at the latest diff as most of these have been addressed.

[clayborg]

I believe you have addressed all of my concerns. Read through my previous comments and make sure, and if so, this is good to go. Nice patch, thanks for working through the abtracting issues we ran into and for making a great patch.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

3883–3884

Per tberghammer's comment we might need to add a way to get a DIERef from a DWARFFormValue...

[paulherman]

I think the only concern left might be the call to DeclLinkToObject in ParseVariableDIE. It doesn't have anything to do with clang but I feel like there should be a way to do this lazily.

Otherwise, I believe that the comments have been addressed.

Thank you!

[clayborg]

Yes, it would be nice to not have to get a variable's decl right up front. Maybe the Variable::GetDecl() could register this mapping if/when the variable decl is made the first time is is asked for?

[paulherman]

Are you suggesting that the DeclLinkToObject is moved inside the GetDecl call and I only remove that? This is the only place where GetDecl is called, so it would be equivalent from a computational point of view. This is because ClangASTContext::DeclContextFindDeclByName assumes that the Decl tree is computed (hence a call to ParseVariablesForContext was placed).

[clayborg]

In D12658#245547, @paulherman wrote:

Are you suggesting that the DeclLinkToObject is moved inside the GetDecl call and I only remove that?

Yes, actually you can probably move it into SymbolFileDWARF::GetDeclForUID(). there should be a cache in this function right? If the item isn't in the cache then we cache it and call DeclLinkToObject().

BTW: DeclLinkToObject() might be able to be moved into the base TypeSystem class?

This is the only place where GetDecl is called, so it would be equivalent from a computational point of view.

Yep, don't care how it happens, I just want it to be lazy and only done if someone asks for it.

[paulherman]

If I move the call to DeclLinkDeclToObject inside any of the GetDeclXXX methods, then there is no way to access the VariableSP needed for the call and it is probably harder to reconstruct the parameters needed for ParseVariableDIE starting from just the DIE itself.

Also, the call is already lazy since ParseVariableDIE is lazy (i.e. whenever the VariableSP is needed, the Decl is needed). I don't think there is any way to separate the call to DeclLinkDeclToObject from ParseVariableDIE, only to make sure that DeclLinkDeclToObject doesn't do any work if it is called with a previously encountered variable.

[paulherman]

I thought about the problem a bit more and I believe that having the call to DeclLinkDeclToObject inside ParseVariableDIE makes sense since this gets called only when the variable will actually be used in a search together with its context. Also, since ParseVariableDIE is lazy, this makes the linking to be lazy.

I don't really see how one could do this inside GetClangDeclForDIE or inside Variable::GetDecl as there is no access to the VariableSP in there.

What can be done is to add the link in ClangExpressionDeclMap after the call to GetInScopeVariableList by iterating through that list as this call is needed to actually parse the variables anyway.

[clayborg]

So I don't like it in ParseVariableDIE() because it means we must create the decl right away for the variable when parsing it. ParseVariableDIE is used to parse all variables everywhere and we don't need the CompilerDecl in order to display the Variable, so we don't need to create it right away. We can always associate it in the Variable::GetDecl() call.

[paulherman]

In D12658#245851, @clayborg wrote:

So I don't like it in ParseVariableDIE() because it means we must create the decl right away for the variable when parsing it. ParseVariableDIE is used to parse all variables everywhere and we don't need the CompilerDecl in order to display the Variable, so we don't need to create it right away. We can always associate it in the Variable::GetDecl() call.

Okay, I understand that. In order to accomplish this, Variable should probably inherit from std::enable_shared_from_this so that we only have one SP to the variable. Is this acceptable?

[clayborg]

We only really need variable to inherit from std::shared_from_this if we have any classes or API that use a "Variable *" as ivars or parameters. If we do, feel free to make it inherit from shared_from_this, but I would like to avoid it if possible to save on space. Also if you convert to shared_from_this, all construction of Variables must be done into shared pointers directly as they are constructed or things will crash.

[paulherman]

I just ran a grep through the source. It seems that everywhere it is created as a shared_ptr. In a previous attempt I tried storing it in the TypeSystem map from decl to object as Variable* instead of VariableSP and it seemed like at some point between launching a query and getting the value of a variable there were no references so the pointer got deleted. Hence, I guess it is kinda needed here.

[paulherman]

Search variables based on clang::DeclContext and clang::Decl tree

Moved the DeclLinkToObject inside Variable::GetDecl.

[tberghammer]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

3883–3884

Using form_value.Reference() as a uid and then passing it to UserIDMatches still have the same issue as before, because form_value.Reference() will return a 32bit DIE offset (the return type might be 64bit, but the data will be only 32)

DIERef has a costructor taking a DWARFFormValue, please use that one and the get the UID from the DIERef (it will store the CU from the form_value, and know how to calculate UID based on it)

[paulherman]

Search variables based on clang::DeclContext and clang::Decl tree

[paulherman]

Search variables based on clang::DeclContext and clang::Decl tree

This adds handling of imported declarations, but there is no call to actually process them as I am not sure where to do this. I believe that the right place is in SymbolFileDWARF::ParseVariablesForContext.

[clayborg]

Looks good as long as my inlined comment doesn't point out an error, then this is good to go! Good stuff.

source/Symbol/Variable.cpp

250–258

As long as calling DeclLinkToObject(...) more than once with the same args is ok, then this will be fine.

[paulherman]

Search variables based on clang::DeclContext and clang::Decl tree

Rebased the patch.

[clayborg]

I am seeing line 89 fail on MacOSX from your new TestCppNsImport.py:

test_result = frame.EvaluateExpression("imported")
self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 99, "imported = 99")

Ours is picking up the global "imported" and it is getting 89. Can you send me the log file from the following commands?:

cd lldb/test/lang/cpp/nsimport
make

Now find the LLDB that you built and use it to debug:

../...../lldb a.out
(lldb) b /break 0/
(lldb) r
(lldb) log enable -f /tmp/expr-log.txt lldb expr
(lldb) p imported
(lldb) log disable lldb expr

Then send me the "expr-log.txt".

On MacOSX, we find the global "imported" in the translation unit:

ClangExpressionDeclMap::FindExternalVisibleDecls[9] for 'imported' in a 'TranslationUnit'

CEDM::FEVD[9] Searching the root namespace
CEDM::FEVD[9] Found variable imported, returned static int &imported (original int)

I am wondering if this works for you because your debug info isn't correctly describing the "imported" global variable. Maybe the one in the translation unit got stripped since it wasn't used? You might need to use it with something like:

::imported = 123;

If you can send me the expression log and possibly your ELF a.out file, I might be able to figure out what is going on.

Greg

[paulherman]

The test was supposed to be marked as an XFAIL. I'm currently writing a fix for this that reports ambiguity in a context and deals with imported decls.

[clayborg]

Ah, the test_with_dsym_and_run_command() wasn't marked as fail...

I fixed the test with:

% svn commit
Sending test/lang/cpp/nsimport/TestCppNsImport.py
Transmitting file data .
Committed revision 247764.

Feel free to correct it. I would also say that we might want to split up the test into multiple test functions so we can test individual things:

• that using namespace works with no ambiguity
• that you can see variables by specifying the global namespace and by specifying the namespace (like I just added with "::imported" and "Imported::imported")
• anything else I missed..

[paulherman]

Please also look at http://reviews.llvm.org/D12897

It fixes the imported decls and some bugs that I have missed (evaluating Fun::fun_var reports an error in TestCppNsImport). Unfortunately I don't think there is a way to report ambiguity without for "imported" without breaking "::imported" (details in the diff above).

include/lldb/Symbol/ClangASTContext.h

LayoutRecordType(void *baton,
                      const clang::RecordDecl *record_decl,
                      uint64_t &size,
                      uint64_t &alignment,
                      llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
                      llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
                      llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets);
 
     //----------------------------------------------------------------------
+    // CompilerDecl override functions
+    //----------------------------------------------------------------------
+    lldb::VariableSP
+    DeclGetVariable (void *opaque_decl) override;
+
+    void
+    DeclLinkToObject (void *opaque_decl, std::shared_ptr<void> object) override;
+    
+    ConstString
+    DeclGetName (void *opaque_decl) override;
+
+    //----------------------------------------------------------------------
     // CompilerDeclContext override functions
     //----------------------------------------------------------------------
     
+    std::vector<void *>
+    DeclContextFindDeclByName (void *opaque_decl_ctx, ConstString name);
+
     bool
     DeclContextIsStructUnionOrClass (void *opaque_decl_ctx) override;
 
     ConstString
     DeclContextGetName (void *opaque_decl_ctx) override;
 
     bool
     DeclContextIsClassMethod (void *opaque_decl_ctx,

 
     clang::ClassTemplateDecl *
     ParseClassTemplateDecl (clang::DeclContext *decl_ctx,
                             lldb::AccessType access_type,
                             const char *parent_name,
                             int tag_decl_kind,
                             const ClangASTContext::TemplateParameterInfos &template_param_infos);
 
+    clang::BlockDecl *
+    CreateBlockDeclaration (clang::DeclContext *ctx);
+
+    clang::UsingDirectiveDecl *
+    CreateUsingDirectiveDeclaration (clang::DeclContext *decl_ctx, clang::NamespaceDecl *ns_decl);
+
+    clang::UsingDecl *
+    CreateUsingDeclaration (clang::DeclContext *current_decl_ctx, clang::NamedDecl *target);
+
+    clang::VarDecl *
+    CreateVariableDeclaration (clang::DeclContext *decl_context, const char *name, clang::QualType type);
 protected:
     static clang::QualType
     GetQualType (void *type)
     {
         if (type)
             return clang::QualType::getFromOpaquePtr(type);
         return clang::QualType();
     }
     
     static clang::QualType
     GetCanonicalQualType (void *type)
     {
         if (type)
             return clang::QualType::getFromOpaquePtr(type).getCanonicalType();
         return clang::QualType();
     }
 
     //------------------------------------------------------------------
     // Classes that inherit from ClangASTContext can see and modify these
     //------------------------------------------------------------------
     std::string                                     m_target_triple;
     std::unique_ptr<clang::ASTContext>              m_ast_ap;
     std::unique_ptr<clang::LangOptions>             m_language_options_ap;
     std::unique_ptr<clang::FileManager>             m_file_manager_ap;
     std::unique_ptr<clang::FileSystemOptions>       m_file_system_options_ap;
     std::unique_ptr<clang::SourceManager>           m_source_manager_ap;
     std::unique_ptr<clang::DiagnosticsEngine>       m_diagnostics_engine_ap;
     std::unique_ptr<clang::DiagnosticConsumer>      m_diagnostic_consumer_ap;
     std::shared_ptr<clang::TargetOptions>           m_target_options_rp;
     std::unique_ptr<clang::TargetInfo>              m_target_info_ap;
     std::unique_ptr<clang::IdentifierTable>         m_identifier_table_ap;
     std::unique_ptr<clang::SelectorTable>           m_selector_table_ap;
     std::unique_ptr<clang::Builtin::Context>        m_builtins_ap;
     std::unique_ptr<DWARFASTParser>                 m_dwarf_ast_parser_ap;
     CompleteTagDeclCallback                         m_callback_tag_decl;
     CompleteObjCInterfaceDeclCallback               m_callback_objc_decl;
     void *                                          m_callback_baton;
     uint32_t                                        m_pointer_byte_size;
     bool                                            m_ast_owned;
+    std::map<void *, std::shared_ptr<void>>         m_decl_objects;
 
 private:
     //------------------------------------------------------------------
     // For ClangASTContext only
     //------------------------------------------------------------------
     ClangASTContext(const ClangASTContext&);
     const ClangASTContext& operator=(const ClangASTContext&);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ClangASTContext_h_

include/lldb/Symbol/CompilerDecl.h

+//===-- CompilerDecl.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_CompilerDecl_h_
+#define liblldb_CompilerDecl_h_
+
+#include "lldb/lldb-private.h"
+#include "lldb/Core/ConstString.h"
+
+namespace lldb_private {
+
+class CompilerDecl
+{
+public:
+    //----------------------------------------------------------------------
+    // Constructors and Destructors
+    //----------------------------------------------------------------------
+    CompilerDecl () :
+        m_type_system  (nullptr),
+        m_opaque_decl (nullptr)
+    {
+    }
+
+    CompilerDecl (TypeSystem *type_system, void *decl) :
+        m_type_system (type_system),
+        m_opaque_decl (decl)
+    {
+    }
+
+    ~CompilerDecl ()
+    {
+    }
+
+    //----------------------------------------------------------------------
+    // Tests
+    //----------------------------------------------------------------------
+
+    explicit operator bool () const
+    {
+        return IsValid ();
+    }
+    
+    bool
+    operator < (const CompilerDecl &rhs) const
+    {
+        if (m_type_system == rhs.m_type_system)
+            return m_opaque_decl < rhs.m_opaque_decl;
+        return m_type_system < rhs.m_type_system;
+    }
+
+    bool
+    IsValid () const
+    {
+        return m_type_system != nullptr && m_opaque_decl != nullptr;
+    }
+
+    bool
+    IsClang () const;
+
+    //----------------------------------------------------------------------
+    // Object linked to the decl
+    //----------------------------------------------------------------------
+    lldb::VariableSP
+    GetAsVariable ();
+
+    //----------------------------------------------------------------------
+    // Accessors
+    //----------------------------------------------------------------------
+    
+    TypeSystem *
+    GetTypeSystem() const
+    {
+        return m_type_system;
+    }
+    
+    void *
+    GetOpaqueDecl() const
+    {
+        return m_opaque_decl;
+    }
+
+    void
+    SetDecl (TypeSystem* type_system, void* decl)
+    {
+        m_type_system = type_system;
+        m_opaque_decl = decl;
+    }
+
+    void
+    Clear()
+    {
+        m_type_system = nullptr;
+        m_opaque_decl = nullptr;
+    }
+
+    ConstString
+    GetName () const;
+
+private:
+    TypeSystem *m_type_system;
+    void *m_opaque_decl;
+};
+    
+bool operator == (const CompilerDecl &lhs, const CompilerDecl &rhs);
+bool operator != (const CompilerDecl &lhs, const CompilerDecl &rhs);
+
+    
+} // namespace lldb_private
+
+#endif // #ifndef liblldb_CompilerDecl_h_

include/lldb/Symbol/CompilerDeclContext.h

public:
     {
         return IsValid ();
     }
     
     bool
     operator < (const CompilerDeclContext &rhs) const
     {
         if (m_type_system == rhs.m_type_system)
-            return m_type_system < rhs.m_type_system;
+            return m_opaque_decl_ctx < rhs.m_opaque_decl_ctx;
         return m_type_system < rhs.m_type_system;
     }
 
     bool
     IsValid () const
     {
         return m_type_system != nullptr && m_opaque_decl_ctx != nullptr;
     }
 
     bool
     IsClang () const;
 
+    std::vector<CompilerDecl>
+    FindDeclByName (ConstString name);
+
     //----------------------------------------------------------------------
     /// Checks if this decl context represents a method of a class.
     ///
     /// @param[out] language_ptr
     ///     If non NULL and \b true is returned from this function,
     ///     this will indicate if the language that respresents the method.
     ///
     /// @param[out] is_instance_method_ptr

include/lldb/Symbol/SymbolFile.h

 //===-- SymbolFile.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_SymbolFile_h_
 #define liblldb_SymbolFile_h_
 
 #include "lldb/lldb-private.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/CompilerType.h"
+#include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 
 #include "lldb/Symbol/Type.h"
 
 namespace lldb_private {
 
 class SymbolFile :
     public PluginInterface
public:
     virtual bool            ParseCompileUnitLineTable (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 &clang_type) = 0;
+    virtual CompilerDecl    GetDeclForUID (lldb::user_id_t uid) { return CompilerDecl(); }
     virtual CompilerDeclContext GetDeclContextForUID (lldb::user_id_t uid) { return CompilerDeclContext(); }
     virtual CompilerDeclContext GetDeclContextContainingUID (lldb::user_id_t uid) { return CompilerDeclContext(); }
     virtual uint32_t        ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) = 0;
     virtual uint32_t        ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list);
     virtual uint32_t        FindGlobalVariables (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, VariableList& variables);
     virtual uint32_t        FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables);
     virtual uint32_t        FindFunctions (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, SymbolContextList& sc_list);
     virtual uint32_t        FindFunctions (const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list);

include/lldb/Symbol/TypeSystem.h

public:
     // Returns true if the symbol file changed during the set accessor.
     virtual void
     SetSymbolFile (SymbolFile *sym_file)
     {
         m_sym_file = sym_file;
     }
 
     //----------------------------------------------------------------------
+    // CompilerDecl functions
+    //----------------------------------------------------------------------
+    virtual ConstString
+    DeclGetName (void *opaque_decl) = 0;
+
+    virtual lldb::VariableSP
+    DeclGetVariable (void *opaque_decl) = 0;
+
+    virtual void
+    DeclLinkToObject (void *opaque_decl, std::shared_ptr<void> object) = 0;
+
+    //----------------------------------------------------------------------
     // CompilerDeclContext functions
     //----------------------------------------------------------------------
     
+    virtual std::vector<void *>
+    DeclContextFindDeclByName (void *opaque_decl_ctx, ConstString name) = 0;
+
     virtual bool
     DeclContextIsStructUnionOrClass (void *opaque_decl_ctx) = 0;
 
     virtual ConstString
     DeclContextGetName (void *opaque_decl_ctx) = 0;
 
     virtual bool
     DeclContextIsClassMethod (void *opaque_decl_ctx,

include/lldb/Symbol/Variable.h

-//===-- Variable.h ----------------------------------------------*- C++ -*-===//
+//===-- Variable.h ----------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
public:
     GetDeclaration() const
     {
         return m_declaration;
     }
 
     ConstString
     GetName() const;
 
+    ConstString
+    GetUnqualifiedName() const;
+
     SymbolContextScope *
     GetSymbolContextScope() const
     {
         return m_owner_scope;
     }
 
     // Since a variable can have a basename "i" and also a mangled 
     // named "_ZN12_GLOBAL__N_11iE" and a demangled mangled name 
GetValuesForVariableExpressionPath (const char *variable_expr_path,
                                         ValueObjectList &valobj_list);
 
     static size_t
     AutoComplete (const ExecutionContext &exe_ctx,
                   const char *name,
                   StringList &matches,
                   bool &word_complete);
 
+    CompilerDeclContext
+    GetDeclContext ();
+
+    CompilerDecl
+    GetDecl ();
 protected:
     ConstString m_name;                 // The basename of the variable (no namespaces)
     Mangled m_mangled;                  // The mangled name of the variable
     lldb::SymbolFileTypeSP m_symfile_type_sp;   // The type pointer of the variable (int, struct, class, etc)
     lldb::ValueType m_scope;            // global, parameter, local
     SymbolContextScope *m_owner_scope;  // The symbol file scope that this variable was defined in
     Declaration m_declaration;          // Declaration location for this item.
     DWARFExpression m_location;         // The location of this variable that can be fed to DWARFExpression::Evaluate()
     uint8_t m_external:1,               // Visible outside the containing compile unit?
             m_artificial:1,             // Non-zero if the variable is not explicitly declared in source
             m_loc_is_const_data:1,      // The m_location expression contains the constant variable value data, not a DWARF location
             m_static_member:1;          // Non-zero if variable is static member of a class or struct.
 private:
     Variable(const Variable& rhs);
     Variable& operator=(const Variable& rhs);
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_Variable_h_

include/lldb/lldb-forward.h

 class   ClangUserExpression;
 class   ClangUtilityFunction;
 class   CommandInterpreter;
 class   CommandInterpreterRunOptions;
 class   CommandObject;
 class   CommandReturnObject;
 class   Communication;
 class   CompactUnwindInfo;
+class   CompilerDecl;
 class   CompilerDeclContext;
 class   CompilerType;
 class   CompileUnit;
 class   Condition;
 class   Connection;
 class   ConnectionFileDescriptor;
 class   ConstString;
 class   CXXSyntheticChildren;

source/Expression/ClangASTSource.cpp

for (TagDecl::decl_iterator iter = original_decl_context->decls_begin();
             if (log)
             {
                 ASTDumper ast_dumper(decl);
                 if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context_decl))
                     log->Printf("  FELD[%d] Adding [to %sDecl %s] lexical %sDecl %s", current_id, context_named_decl->getDeclKindName(), context_named_decl->getNameAsString().c_str(), decl->getDeclKindName(), ast_dumper.GetCString());
                 else
                     log->Printf("  FELD[%d] Adding lexical %sDecl %s", current_id, decl->getDeclKindName(), ast_dumper.GetCString());
             }
             
             Decl *copied_decl = m_ast_importer->CopyDecl(m_ast_context, original_ctx, decl);
 
             if (!copied_decl)
                 continue;
 
             if (FieldDecl *copied_field = dyn_cast<FieldDecl>(copied_decl))
             {
                 QualType copied_field_type = copied_field->getType();

source/Expression/ClangExpressionDeclMap.cpp

 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/ASTDumper.h"
 #include "lldb/Expression/ClangASTSource.h"
 #include "lldb/Expression/ClangModulesDeclVendor.h"
 #include "lldb/Expression/ClangPersistentVariables.h"
 #include "lldb/Expression/Materializer.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context,
 
     if (name == id_name || name == Class_name)
         return;
 
     // Only look for functions by name out in our symbols if the function
     // doesn't start with our phony prefix of '$'
     Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
     StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
+    SymbolContext sym_ctx;
+    if (frame != nullptr)
+        sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction|lldb::eSymbolContextBlock);
     if (name_unique_cstr[0] == '$' && !namespace_decl)
     {
         static ConstString g_lldb_class_name ("$__lldb_class");
 
         if (name == g_lldb_class_name)
         {
             // Clang is looking for the type of "this"
 
             if (frame == NULL)
                 return;
 
-            SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction|lldb::eSymbolContextBlock);
 
             // Find the block that defines the function represented by "sym_ctx"
             Block *function_block = sym_ctx.GetFunctionBlock();
 
             if (!function_block)
                 return;
 
             CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context,
     else
     {
         ValueObjectSP valobj;
         VariableSP var;
         Error err;
 
         if (frame && !namespace_decl)
         {
-            valobj = frame->GetValueForVariableExpressionPath(name_unique_cstr,
-                                                              eNoDynamicValues,
-                                                              StackFrame::eExpressionPathOptionCheckPtrVsMember |
-                                                              StackFrame::eExpressionPathOptionsNoFragileObjcIvar |
-                                                              StackFrame::eExpressionPathOptionsNoSyntheticChildren |
-                                                              StackFrame::eExpressionPathOptionsNoSyntheticArrayRange,
-                                                              var,
-                                                              err);
+            CompilerDeclContext compiler_decl_context = sym_ctx.block != nullptr ? sym_ctx.block->GetDeclContext() : CompilerDeclContext();
 
-            // If we found a variable in scope, no need to pull up function names
-            if (err.Success() && var)
+            if (compiler_decl_context)
             {
+                // Make sure that the variables are parsed so that we have the declarations
+                frame->GetInScopeVariableList(true);
+
+                // Search for declarations matching the name
+                std::vector<CompilerDecl> found_decls = compiler_decl_context.FindDeclByName(name);
+                for (CompilerDecl decl : found_decls)
+                {
+                    var = decl.GetAsVariable();
+                    if (var)
+                    {
+                        valobj = ValueObjectVariable::Create(frame, var);
                         AddOneVariable(context, var, valobj, current_id);
                         context.m_found.variable = true;
                         return;
                     }
                 }
-
+            }
+        }
         if (target)
         {
             var = FindGlobalVariable (*target,
                                       module_sp,
                                       name,
                                       &namespace_decl,
                                       NULL);
 

source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

public:
     virtual ~DWARFASTParser() {}
 
     virtual lldb::TypeSP
     ParseTypeFromDWARF (const lldb_private::SymbolContext& sc,
                         const DWARFDIE &die,
                         lldb_private::Log *log,
                         bool *type_is_new_ptr) = 0;
 
-
     virtual lldb_private::Function *
     ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc,
                             const DWARFDIE &die) = 0;
 
     virtual bool
     CompleteTypeFromDWARF (const DWARFDIE &die,
                            lldb_private::Type *type,
                            lldb_private::CompilerType &clang_type) = 0;
 
+    virtual lldb_private::CompilerDecl
+    GetDeclForUIDFromDWARF (const DWARFDIE &die) = 0;
+
     virtual lldb_private::CompilerDeclContext
     GetDeclContextForUIDFromDWARF (const DWARFDIE &die) = 0;
 
     virtual lldb_private::CompilerDeclContext
     GetDeclContextContainingUIDFromDWARF (const DWARFDIE &die) = 0;
-
 };
 
 #endif  // SymbolFileDWARF_DWARFASTParser_h_

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

public:
     ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc,
                             const DWARFDIE &die) override;
 
     virtual bool
     CompleteTypeFromDWARF (const DWARFDIE &die,
                            lldb_private::Type *type,
                            lldb_private::CompilerType &clang_type) override;
 
+    virtual lldb_private::CompilerDecl
+    GetDeclForUIDFromDWARF (const DWARFDIE &die) override;
+
     virtual lldb_private::CompilerDeclContext
     GetDeclContextForUIDFromDWARF (const DWARFDIE &die) override;
 
     virtual lldb_private::CompilerDeclContext
     GetDeclContextContainingUIDFromDWARF (const DWARFDIE &die) override;
 
     bool
     LayoutRecordType(const clang::RecordDecl *record_decl,
struct LayoutInfo
         }
         uint64_t bit_size;
         uint64_t alignment;
         llvm::DenseMap<const clang::FieldDecl *, uint64_t> field_offsets;
         llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> base_offsets;
         llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> vbase_offsets;
     };
 
+    clang::BlockDecl *
+    ResolveBlockDIE (const DWARFDIE &die);
+
     clang::NamespaceDecl *
     ResolveNamespaceDIE (const DWARFDIE &die);
 
     typedef llvm::DenseMap<const clang::RecordDecl *, LayoutInfo> RecordDeclToLayoutMap;
 
     bool
     ParseTemplateDIE (const DWARFDIE &die,
                       lldb_private::ClangASTContext::TemplateParameterInfos &template_param_infos);
protected:
 
     size_t
     ParseChildEnumerators (const lldb_private::SymbolContext& sc,
                            lldb_private::CompilerType &clang_type,
                            bool is_signed,
                            uint32_t enumerator_byte_size,
                            const DWARFDIE &parent_die);
 
+    lldb_private::Type *
+    GetTypeForDIE (const DWARFDIE &die);
+
+    clang::Decl *
+    GetClangDeclForDIE (const DWARFDIE &die);
+
     clang::DeclContext *
     GetClangDeclContextForDIE (const DWARFDIE &die);
 
     clang::DeclContext *
     GetClangDeclContextContainingDIE (const DWARFDIE &die,
                                       DWARFDIE *decl_ctx_die);
 
     bool
     CopyUniqueClassMethodTypes (const DWARFDIE &src_class_die,
                                 const DWARFDIE &dst_class_die,
                                 lldb_private::Type *class_type,
                                 DWARFDIECollection &failures);
 
     clang::DeclContext *
     GetCachedClangDeclContextForDIE (const DWARFDIE &die);
 
     void
     LinkDeclContextToDIE (clang::DeclContext *decl_ctx,
                           const DWARFDIE &die);
 
+    void
+    LinkDeclToDIE (clang::Decl *decl, const DWARFDIE &die);
+
     typedef llvm::SmallPtrSet<const DWARFDebugInfoEntry *, 4> DIEPointerSet;
     typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *> DIEToDeclContextMap;
     typedef llvm::DenseMap<const clang::DeclContext *, DIEPointerSet> DeclContextToDIEMap;
+    typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *> DIEToDeclMap;
+    typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap;
 
     lldb_private::ClangASTContext &m_ast;
+    DIEToDeclMap m_die_to_decl;
+    DeclToDIEMap m_decl_to_die;
     DIEToDeclContextMap m_die_to_decl_ctx;
     DeclContextToDIEMap m_decl_ctx_to_die;
     RecordDeclToLayoutMap m_record_decl_to_layout_map;
 };
 
 #endif  // SymbolFileDWARF_DWARFASTParserClang_h_

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

struct BitfieldInfo
 
     bool IsValid ()
     {
         return (bit_size != LLDB_INVALID_ADDRESS) &&
         (bit_offset != LLDB_INVALID_ADDRESS);
     }
 };
 
-
 TypeSP
 DWARFASTParserClang::ParseTypeFromDWARF (const SymbolContext& sc,
                                          const DWARFDIE &die,
                                          Log *log,
                                          bool *type_is_new_ptr)
 {
     TypeSP type_sp;
 
switch (tag)
         default:
             assert(false && "not a forward clang type decl!");
             break;
     }
 
     return false;
 }
 
+CompilerDecl
+DWARFASTParserClang::GetDeclForUIDFromDWARF (const DWARFDIE &die)
+{
+    clang::Decl *clang_decl = GetClangDeclForDIE(die);
+    if (clang_decl != nullptr)
+        return CompilerDecl(&m_ast, clang_decl);
+    return CompilerDecl();
+}
+
 CompilerDeclContext
 DWARFASTParserClang::GetDeclContextForUIDFromDWARF (const DWARFDIE &die)
 {
     clang::DeclContext *clang_decl_ctx = GetClangDeclContextForDIE (die);
     if (clang_decl_ctx)
         return CompilerDeclContext(&m_ast, clang_decl_ctx);
     return CompilerDeclContext();
 }
public:
     };
 
 protected:
     typedef std::vector<DWARFDIE> Stack;
     Stack m_dies;
 };
 #endif
 
-
 Function *
 DWARFASTParserClang::ParseFunctionFromDWARF (const SymbolContext& sc,
                                              const DWARFDIE &die)
 {
     DWARFRangeList func_ranges;
     const char *name = NULL;
     const char *mangled = NULL;
     int decl_file = 0;
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
                     element_orders.push_back (num_elements);
                 }
             }
                 break;
         }
     }
 }
 
+Type *
+DWARFASTParserClang::GetTypeForDIE (const DWARFDIE &die)
+{
+    if (die)
+    {
+        SymbolFileDWARF *dwarf = die.GetDWARF();
+        DWARFAttributes attributes;
+        const size_t num_attributes = die.GetAttributes(attributes);
+        if (num_attributes > 0)
+        {
+            DWARFFormValue type_die_form;
+            for (size_t i = 0; i < num_attributes; ++i)
+            {
+                dw_attr_t attr = attributes.AttributeAtIndex(i);
+                DWARFFormValue form_value;
+                
+                if (attr == DW_AT_type && attributes.ExtractFormValueAtIndex(i, form_value))
+                    return dwarf->ResolveTypeUID(DIERef(form_value).GetUID());
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+clang::Decl *
+DWARFASTParserClang::GetClangDeclForDIE (const DWARFDIE &die)
+{
+    if (!die)
+        return nullptr;
+
+    clang::Decl *decl = m_die_to_decl[die.GetDIE()];
+    if (decl != nullptr)
+        return decl;
+
+    switch (die.Tag())
+    {
+        case DW_TAG_variable:
+        case DW_TAG_constant:
+        case DW_TAG_formal_parameter:
+        {
+            SymbolFileDWARF *dwarf = die.GetDWARF();
+            Type *type = GetTypeForDIE(die);
+            const char *name = die.GetName();
+            clang::DeclContext *decl_context = ClangASTContext::DeclContextGetAsDeclContext(dwarf->GetDeclContextContainingUID(die.GetID()));
+                decl = m_ast.CreateVariableDeclaration(
+                    decl_context,
+                    name,
+                    ClangASTContext::GetQualType(type->GetForwardCompilerType()));
+            break;
+        }
+        default:
+            break;
+    }
+
+    m_die_to_decl[die.GetDIE()] = decl;
+    m_decl_to_die[decl].insert(die.GetDIE());
+
+    return decl;
+}
+
 clang::DeclContext *
 DWARFASTParserClang::GetClangDeclContextForDIE (const DWARFDIE &die)
 {
     if (die)
     {
         clang::DeclContext *decl_ctx = GetCachedClangDeclContextForDIE (die);
         if (decl_ctx)
             return decl_ctx;
 
         bool try_parsing_type = true;
         switch (die.Tag())
         {
             case DW_TAG_compile_unit:
                 decl_ctx = m_ast.GetTranslationUnitDecl();
                 try_parsing_type = false;
                 break;
 
             case DW_TAG_namespace:
                 decl_ctx = ResolveNamespaceDIE (die);
                 try_parsing_type = false;
                 break;
 
+            case DW_TAG_lexical_block:
+                decl_ctx = (clang::DeclContext *)ResolveBlockDIE(die);
+                try_parsing_type = false;
+                break;
+
             default:
                 break;
         }
 
         if (decl_ctx == nullptr && try_parsing_type)
         {
             Type* type = die.GetDWARF()->ResolveType (die);
             if (type)
                 decl_ctx = GetCachedClangDeclContextForDIE (die);
         }
 
         if (decl_ctx)
         {
             LinkDeclContextToDIE (decl_ctx, die);
             return decl_ctx;
         }
     }
     return nullptr;
 }
 
+clang::BlockDecl *
+DWARFASTParserClang::ResolveBlockDIE (const DWARFDIE &die)
+{
+    if (die && die.Tag() == DW_TAG_lexical_block)
+    {
+        clang::BlockDecl *decl = llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.GetDIE()]);
+        
+        if (!decl)
+        {
+            DWARFDIE decl_context_die;
+            clang::DeclContext *decl_context = GetClangDeclContextContainingDIE(die, &decl_context_die);
+            decl = m_ast.CreateBlockDeclaration(decl_context);
+
+            if (decl)
+                LinkDeclContextToDIE((clang::DeclContext *)decl, die);
+        }
+
+        return decl;
+    }
+    return nullptr;
+}
+
 clang::NamespaceDecl *
 DWARFASTParserClang::ResolveNamespaceDIE (const DWARFDIE &die)
 {
     if (die && die.Tag() == DW_TAG_namespace)
     {
         // See if we already parsed this namespace DIE and associated it with a
         // uniqued namespace declaration
         clang::NamespaceDecl *namespace_decl = static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]);
DWARFASTParserClang::GetClangDeclContextContainingDIE (const DWARFDIE &die,
     {
         clang::DeclContext *clang_decl_ctx = GetClangDeclContextForDIE (decl_ctx_die);
         if (clang_decl_ctx)
             return clang_decl_ctx;
     }
     return m_ast.GetTranslationUnitDecl();
 }
 
-
-
-
-
 clang::DeclContext *
 DWARFASTParserClang::GetCachedClangDeclContextForDIE (const DWARFDIE &die)
 {
     if (die)
     {
         DIEToDeclContextMap::iterator pos = m_die_to_decl_ctx.find(die.GetDIE());
         if (pos != m_die_to_decl_ctx.end())
             return pos->second;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
 
     bool
     CompleteType (lldb_private::CompilerType& clang_type) override;
 
     lldb_private::Type *
     ResolveType (const DWARFDIE &die,
                  bool assert_not_being_parsed = true);
 
+    lldb_private::CompilerDecl
+    GetDeclForUID (lldb::user_id_t uid) override;
+
     lldb_private::CompilerDeclContext
     GetDeclContextForUID (lldb::user_id_t uid) override;
 
     lldb_private::CompilerDeclContext
     GetDeclContextContainingUID (lldb::user_id_t uid) override;
 
     uint32_t
     ResolveSymbolContext (const lldb_private::Address& so_addr,

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 
 #include "lldb/Symbol/Block.h"
+#include "lldb/Symbol/CompilerDecl.h"
+#include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/VariableList.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
while (die)
                         std::unique_ptr<Declaration> call_ap;
                         if (call_file != 0 || call_line != 0 || call_column != 0)
                             call_ap.reset(new Declaration(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(call_file), 
                                                           call_line, call_column));
 
                         block->SetInlinedFunctionInfo (name, mangled_name, decl_ap.get(), call_ap.get());
                     }
 
                     ++blocks_added;
 
                     if (die.HasChildren())
                     {
                         blocks_added += ParseFunctionBlocks (sc, 
                                                              block, 
                                                              die.GetFirstChild(),
                                                              subprogram_low_pc, 
                                                              depth + 1);
                     }
                 }
             }
             break;
         default:
             break;
         }
 
         // Only parse siblings of the block if we are not at depth zero. A depth
         // of zero indicates we are currently parsing the top level 
if (parent_die)
                 if (die.GetAttributeValueAsUnsigned(DW_AT_virtuality, 0) != 0)
                     return true;
             }
         }
     }
     return false;
 }
 
+CompilerDecl
+SymbolFileDWARF::GetDeclForUID (lldb::user_id_t type_uid)
+{
+    if (UserIDMatches(type_uid))
+    {
+        DWARFDebugInfo* debug_info = DebugInfo();
+        if (debug_info)
+        {
+            DWARFDIE die = debug_info->GetDIE(DIERef(type_uid));
+            if (die)
+            {
+                DWARFASTParser *dwarf_ast = die.GetDWARFParser();
+                if (dwarf_ast)
+                    return dwarf_ast->GetDeclForUIDFromDWARF(die);
+            }
+        }
+    }
+    return CompilerDecl();
+}
+
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextForUID (lldb::user_id_t type_uid)
 {
     if (UserIDMatches(type_uid))
     {
         DWARFDebugInfo* debug_info = DebugInfo();
         if (debug_info)
         {
if (orig_die)
             {            
                 switch (die.Tag())
                 {
                     case DW_TAG_compile_unit:
                     case DW_TAG_namespace:
                     case DW_TAG_structure_type:
                     case DW_TAG_union_type:
                     case DW_TAG_class_type:
+                    case DW_TAG_lexical_block:
+                    case DW_TAG_subprogram:
                         return die;
                         
                     default:
                         break;
                 }
             }
 
             DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification);
if (sc.comp_unit != NULL)
                             if (m_using_apple_tables)
                             {
                                 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x)\n", die_ref.die_offset);
                             }
                         }            
 
                     }
                 }
             }
             return vars_added;
         }
     }
     return 0;
 }
 
 VariableSP
 SymbolFileDWARF::ParseVariableDIE
 (
     const SymbolContext& sc,
     const DWARFDIE &die,
     const lldb::addr_t func_low_pc
 )
 {
     if (die.GetDWARF() != this)
         return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc);
 
     VariableSP var_sp;
     if (!die)
         return var_sp;
 
     var_sp = GetDIEToVariable()[die.GetDIE()];
     if (var_sp)
         return var_sp;  // Already been parsed!
     
     const dw_tag_t tag = die.Tag();
     ModuleSP module = GetObjectFile()->GetModule();
     
     if ((tag == DW_TAG_variable) ||
         (tag == DW_TAG_constant) ||
         (tag == DW_TAG_formal_parameter && sc.function))
     {
         DWARFAttributes attributes;
         const size_t num_attributes = die.GetAttributes(attributes);
+        DWARFDIE spec_die;
         if (num_attributes > 0)
         {
             const char *name = NULL;
             const char *mangled = NULL;
             Declaration decl;
             uint32_t i;
             DWARFFormValue type_die_form;
             DWARFExpression location(die.GetCU());
             bool is_external = false;
             bool is_artificial = false;
             bool location_is_const_value_data = false;
             bool has_explicit_location = false;
             DWARFFormValue const_value;
             //AccessType accessibility = eAccessNone;
 
             for (i=0; i<num_attributes; ++i)
             {
                 dw_attr_t attr = attributes.AttributeAtIndex(i);
                 DWARFFormValue form_value;
                 
                 if (attributes.ExtractFormValueAtIndex(i, form_value))
                 {
                     switch (attr)
                     {
                     case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
                     case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
                     case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
                     case DW_AT_name:        name = form_value.AsCString(); break;
                     case DW_AT_linkage_name:
                     case DW_AT_MIPS_linkage_name: mangled = form_value.AsCString(); break;
                     case DW_AT_type:        type_die_form = form_value; break;
                     case DW_AT_external:    is_external = form_value.Boolean(); break;
                     case DW_AT_const_value:
                         // If we have already found a DW_AT_location attribute, ignore this attribute.
                         if (!has_explicit_location)
                         {
                             location_is_const_value_data = true;
                             // The constant value will be either a block, a data value or a string.
                             const DWARFDataExtractor& debug_info_data = get_debug_info_data();
                             if (DWARFFormValue::IsBlockForm(form_value.Form()))
                             {
if ((tag == DW_TAG_variable) ||
                                 {
                                     location.CopyOpcodeData(module, debug_loc_data, debug_loc_offset, loc_list_length);
                                     assert (func_low_pc != LLDB_INVALID_ADDRESS);
                                     location.SetLocationListSlide (func_low_pc - attributes.CompileUnitAtIndex(i)->GetBaseAddress());
                                 }
                             }
                         }
                         break;
-
+                    case DW_AT_specification:
+                    {
+                        lldb::user_id_t spec_uid = form_value.Reference();
+                        if (UserIDMatches(spec_uid))
+                        {
+                            DWARFDebugInfo* debug_info = DebugInfo();
+                            if (debug_info)
+                                spec_die = debug_info->GetDIE(DIERef(spec_uid));
+                        }
+                        break;
+                    }
                     case DW_AT_artificial:      is_artificial = form_value.Boolean(); break;
                     case DW_AT_accessibility:   break; //accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
                     case DW_AT_declaration:
                     case DW_AT_description:
                     case DW_AT_endianity:
                     case DW_AT_segment:
                     case DW_AT_start_scope:
                     case DW_AT_visibility:
                     default:
                     case DW_AT_abstract_origin:
                     case DW_AT_sibling:
-                    case DW_AT_specification:
                         break;
                     }
                 }
             }
 
             const DWARFDIE parent_context_die = GetDeclContextDIEContainingDIE(die);
             const dw_tag_t parent_tag = die.GetParent().Tag();
             bool is_static_member = parent_tag == DW_TAG_compile_unit && (parent_context_die.Tag() == DW_TAG_class_type || parent_context_die.Tag() == DW_TAG_structure_type);
if ((tag == DW_TAG_variable) ||
                 return var_sp;
             }
         }
         // Cache var_sp even if NULL (the variable was just a specification or
         // was missing vital information to be able to be displayed in the debugger
         // (missing location due to optimization, etc)) so we don't re-parse
         // this DIE over and over later...
         GetDIEToVariable()[die.GetDIE()] = var_sp;
+        if (spec_die)
+            GetDIEToVariable()[spec_die.GetDIE()] = var_sp;
+
+        if (var_sp)
+        {
+            CompilerDecl decl = var_sp->GetDecl(); 
+            if (decl)
+                decl.GetTypeSystem()->DeclLinkToObject(decl.GetOpaqueDecl(), var_sp);
+        }
     }
     return var_sp;
 }
 
 
 DWARFDIE
 SymbolFileDWARF::FindBlockContainingSpecification (const DIERef& func_die_ref,
                                                    dw_offset_t spec_block_die_offset)
 {
     // Give the concrete function die specified by "func_die_offset", find the 
     // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
     // to "spec_block_die_offset"
     return FindBlockContainingSpecification (DebugInfo()->GetDIE (func_die_ref), spec_block_die_offset);
 }
 
while (die)
                     {
                         variable_list_sp->AddVariableIfUnique (var_sp);
                         if (cc_variable_list)
                             cc_variable_list->AddVariableIfUnique (var_sp);
                         ++vars_added;
                     }
                 }
             }
         }
 
         bool skip_children = (sc.function == NULL && tag == DW_TAG_subprogram);
 
         if (!skip_children && parse_children && die.HasChildren())
         {
             vars_added += ParseVariables(sc, die.GetFirstChild(), func_low_pc, true, true, cc_variable_list);
         }
 
         if (parse_siblings)

source/Symbol/CMakeLists.txt

 add_lldb_library(lldbSymbol
   Block.cpp
   ClangASTContext.cpp
   ClangASTImporter.cpp
   ClangExternalASTSourceCallbacks.cpp
   ClangExternalASTSourceCommon.cpp
+  CompilerDecl.cpp
   CompilerDeclContext.cpp
   CompilerType.cpp
   CompileUnit.cpp
   CompactUnwindInfo.cpp
   Declaration.cpp
   DWARFCallFrameInfo.cpp
   Function.cpp
   FuncUnwinders.cpp

source/Symbol/ClangASTContext.cpp

ClangASTContext::GetUniqueNamespaceDeclaration (const char *name, DeclContext *decl_ctx)
     }
 #ifdef LLDB_CONFIGURATION_DEBUG
     VerifyDecl(namespace_decl);
 #endif
     return namespace_decl;
 }
 
 
+clang::BlockDecl *
+ClangASTContext::CreateBlockDeclaration (clang::DeclContext *ctx)
+{
+    if (ctx != nullptr)
+    {
+        clang::BlockDecl *decl = clang::BlockDecl::Create(*getASTContext(), ctx, clang::SourceLocation());
+        ctx->addDecl(decl);
+        return decl;
+    }
+    return nullptr;
+}
+
+clang::UsingDirectiveDecl *
+ClangASTContext::CreateUsingDirectiveDeclaration (clang::DeclContext *decl_ctx, clang::NamespaceDecl *ns_decl)
+{
+    if (decl_ctx != nullptr && ns_decl != nullptr)
+    {
+        // TODO: run LCA between decl_tx and ns_decl
+        clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create(*getASTContext(),
+            decl_ctx,
+            clang::SourceLocation(),
+            clang::SourceLocation(),
+            clang::NestedNameSpecifierLoc(),
+            clang::SourceLocation(),
+            ns_decl,
+            GetTranslationUnitDecl(getASTContext()));
+        decl_ctx->addDecl(using_decl);
+        return using_decl;
+    }
+    return nullptr;
+}
+
+clang::UsingDecl *
+ClangASTContext::CreateUsingDeclaration (clang::DeclContext *current_decl_ctx, clang::NamedDecl *target)
+{
+    if (current_decl_ctx != nullptr && target != nullptr)
+    {
+        clang::UsingDecl *using_decl = clang::UsingDecl::Create(*getASTContext(),
+            current_decl_ctx,
+            clang::SourceLocation(),
+            clang::NestedNameSpecifierLoc(),
+            clang::DeclarationNameInfo(),
+            false);
+        clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(*getASTContext(),
+            current_decl_ctx,
+            clang::SourceLocation(),
+            using_decl,
+            target);
+        using_decl->addShadowDecl(shadow_decl);
+        current_decl_ctx->addDecl(using_decl);
+        return using_decl;
+    }
+    return nullptr;
+}
+
+clang::VarDecl *
+ClangASTContext::CreateVariableDeclaration (clang::DeclContext *decl_context, const char *name, clang::QualType type)
+{
+    if (decl_context != nullptr)
+    {
+        clang::VarDecl *var_decl = clang::VarDecl::Create(*getASTContext(),
+            decl_context,
+            clang::SourceLocation(),
+            clang::SourceLocation(),
+            name && name[0] ? &getASTContext()->Idents.getOwn(name) : nullptr,
+            type,
+            nullptr,
+            clang::SC_None);
+        var_decl->setAccess(clang::AS_public);
+        decl_context->addDecl(var_decl);
+        decl_context->makeDeclVisibleInContext(var_decl);
+        return var_decl;
+    }
+    return nullptr;
+}
+
 #pragma mark Function Types
 
 FunctionDecl *
 ClangASTContext::CreateFunctionDeclaration (DeclContext *decl_ctx,
                                             const char *name,
                                             const CompilerType &function_clang_type,
                                             int storage,
                                             bool is_inline)
ClangASTContext::LayoutRecordType(void *baton,
                                   llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets)
 {
     ClangASTContext *ast = (ClangASTContext *)baton;
     DWARFASTParserClang *dwarf_ast_parser = (DWARFASTParserClang *)ast->GetDWARFParser();
     return dwarf_ast_parser->LayoutRecordType(record_decl, bit_size, alignment, field_offsets, base_offsets, vbase_offsets);
 }
 
 //----------------------------------------------------------------------
+// CompilerDecl override functions
+//----------------------------------------------------------------------
+lldb::VariableSP
+ClangASTContext::DeclGetVariable (void *opaque_decl)
+{
+    if (llvm::dyn_cast<clang::VarDecl>((clang::Decl *)opaque_decl))
+    {
+        auto decl_search_it = m_decl_objects.find(opaque_decl);
+        if (decl_search_it != m_decl_objects.end())
+            return std::static_pointer_cast<Variable>(decl_search_it->second);
+    }
+    return VariableSP();
+}
+
+void
+ClangASTContext::DeclLinkToObject (void *opaque_decl, std::shared_ptr<void> object)
+{
+    assert(m_decl_objects.find(opaque_decl) == m_decl_objects.end());
+    m_decl_objects.insert(std::make_pair(opaque_decl, object));
+}
+
+ConstString
+ClangASTContext::DeclGetName (void *opaque_decl)
+{
+    if (opaque_decl)
+    {
+        clang::NamedDecl *nd = llvm::dyn_cast<NamedDecl>((clang::Decl*)opaque_decl);
+        if (nd != nullptr)
+            return ConstString(nd->getName());
+    }
+    return ConstString();
+}
+
+//----------------------------------------------------------------------
 // CompilerDeclContext functions
 //----------------------------------------------------------------------
 
+std::vector<void *>
+ClangASTContext::DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name)
+{
+    std::vector<void *> found_decls;
+    if (opaque_decl_ctx)
+    {
+        DeclContext *root_decl_ctx = (DeclContext *)opaque_decl_ctx;
+        std::set<DeclContext *> searched;
+        std::multimap<DeclContext *, DeclContext *> search_queue;
+
+        for (clang::DeclContext *decl_context = root_decl_ctx; decl_context != nullptr && found_decls.empty(); decl_context = decl_context->getParent())
+        {
+            search_queue.insert(std::make_pair(decl_context, decl_context));
+
+            for (auto it = search_queue.find(decl_context); it != search_queue.end(); it++)
+            {
+                searched.insert(it->second);
+                for (clang::Decl *child : it->second->decls())
+                {
+                    if (clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(child))
+                    {
+                        IdentifierInfo *ii = nd->getIdentifier();
+                        if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr)))
+                            found_decls.push_back(nd);
+                    }
+                    else if (clang::UsingDirectiveDecl *ud = llvm::dyn_cast<clang::UsingDirectiveDecl>(child))
+                    {
+                        clang::DeclContext *from = ud->getCommonAncestor();
+                        if (searched.find(ud->getNominatedNamespace()) == searched.end())
+                            search_queue.insert(std::make_pair(from, ud->getNominatedNamespace()));
+                    }
+                    else if (clang::UsingDecl *ud = llvm::dyn_cast<clang::UsingDecl>(child))
+                    {
+                        for (clang::UsingShadowDecl *usd : ud->shadows())
+                        {
+                            clang::Decl *target = usd->getTargetDecl();
+                            if (clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(target))
+                            {
+                                IdentifierInfo *ii = nd->getIdentifier();
+                                if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr)))
+                                    found_decls.push_back(nd);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return found_decls;
+}
+
 bool
 ClangASTContext::DeclContextIsStructUnionOrClass (void *opaque_decl_ctx)
 {
     if (opaque_decl_ctx)
         return ((clang::DeclContext *)opaque_decl_ctx)->isRecord();
     else
         return false;
 }

source/Symbol/CompilerDecl.cpp

+//===-- CompilerDecl.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/CompilerDecl.h"
+#include "lldb/Symbol/CompilerDeclContext.h"
+#include "lldb/Symbol/TypeSystem.h"
+
+using namespace lldb_private;
+
+bool
+CompilerDecl::IsClang () const
+{
+    return IsValid() && m_type_system->getKind() == TypeSystem::eKindClang;
+}
+
+ConstString
+CompilerDecl::GetName() const
+{
+    return m_type_system->DeclGetName(m_opaque_decl);
+}
+
+lldb::VariableSP
+CompilerDecl::GetAsVariable ()
+{
+    return m_type_system->DeclGetVariable(m_opaque_decl);
+}
+
+bool
+lldb_private::operator == (const lldb_private::CompilerDecl &lhs, const lldb_private::CompilerDecl &rhs)
+{
+    return lhs.GetTypeSystem() == rhs.GetTypeSystem() && lhs.GetOpaqueDecl() == rhs.GetOpaqueDecl();
+}
+
+
+bool
+lldb_private::operator != (const lldb_private::CompilerDecl &lhs, const lldb_private::CompilerDecl &rhs)
+{
+    return lhs.GetTypeSystem() != rhs.GetTypeSystem() || lhs.GetOpaqueDecl() != rhs.GetOpaqueDecl();
+}
+

source/Symbol/CompilerDeclContext.cpp

 //===-- CompilerDeclContext.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/CompilerDeclContext.h"
+#include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/TypeSystem.h"
+#include <vector>
 
 using namespace lldb_private;
 
+std::vector<CompilerDecl>
+CompilerDeclContext::FindDeclByName (ConstString name)
+{
+    std::vector<CompilerDecl> found_decls;
+    if (IsValid())
+    {
+        std::vector<void *> found_opaque_decls = m_type_system->DeclContextFindDeclByName(m_opaque_decl_ctx, name);
+        for (void *opaque_decl : found_opaque_decls)
+            found_decls.push_back(CompilerDecl(m_type_system, opaque_decl));
+    }
+    return found_decls;
+}
+
 bool
 CompilerDeclContext::IsClang () const
 {
     return IsValid() && m_type_system->getKind() == TypeSystem::eKindClang;
 }
 
 ConstString
 CompilerDeclContext::GetName () const

source/Symbol/Variable.cpp

 #include "lldb/Symbol/Variable.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Symbol/Block.h"
+#include "lldb/Symbol/CompilerDecl.h"
+#include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/Target.h"

 Variable::GetName() const
 {
     ConstString name = m_mangled.GetName(GetLanguage());
     if (name)
         return name;
     return m_name;
 }
 
+ConstString
+Variable::GetUnqualifiedName() const
+{
+    return m_name;
+}
+
+
 bool
 Variable::NameMatches (const ConstString &name) const
 {
     if (m_name == name)
         return true;
     SymbolContext variable_sc;
     m_owner_scope->CalculateSymbolContext(&variable_sc);
 

 }
 
 size_t
 Variable::MemorySize() const
 {
     return sizeof(Variable);
 }
 
+CompilerDeclContext
+Variable::GetDeclContext ()
+{
+    Type *type = GetType();
+    return type->GetSymbolFile()->GetDeclContextContainingUID(GetID());
+}
+
+CompilerDecl
+Variable::GetDecl ()
+{
+    Type *type = GetType();
+    return type->GetSymbolFile()->GetDeclForUID(GetID());
+}
 
 void
 Variable::CalculateSymbolContext (SymbolContext *sc)
 {
     if (m_owner_scope)
     {
         m_owner_scope->CalculateSymbolContext(sc);
         sc->variable = this;
     }
     else
         sc->Clear(false);

test/lang/cpp/nsimport/TestCppNsImport.py

class TestCppNsImport(TestBase):
 
     @skipUnlessDarwin
     @dsym_test
     def test_with_dsym_and_run_command(self):
         """Tests imported namespaces in C++."""
         self.buildDsym()
         self.check()
 
+    # This test is expected to fail because DW_TAG_imported_declaration and DW_TAG_imported_module are not parsed in SymbolFileDWARF
+    @expectedFailureAll
     @dwarf_test
     def test_with_dwarf_and_run_command(self):
         """Tests imported namespaces in C++."""
         self.buildDwarf()
         self.check()
 
     def setUp(self):
         TestBase.setUp(self)
def check(self):
 
         # Load the executable
         target = self.dbg.CreateTarget(exe_path)
         self.assertTrue(target.IsValid(), VALID_TARGET)
 
         # Break on main function
         break_0 = target.BreakpointCreateBySourceRegex("// break 0", src_file_spec)
         self.assertTrue(break_0.IsValid() and break_0.GetNumLocations() >= 1, VALID_BREAKPOINT)
+        break_1 = target.BreakpointCreateBySourceRegex("// break 1", src_file_spec)
+        self.assertTrue(break_1.IsValid() and break_1.GetNumLocations() >= 1, VALID_BREAKPOINT)
 
         # Launch the process
         args = None
         env = None
         process = target.LaunchSimple(args, env, self.get_process_working_directory())
         self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
 
         # Get the thread of the process
def check(self):
         self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 1, "N::n = 1")
 
         test_result = frame.EvaluateExpression("nested")
         self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 3, "nested = 3")
 
         test_result = frame.EvaluateExpression("anon")
         self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 2, "anon = 2")
 
+        test_result = frame.EvaluateExpression("global")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 4, "global = 4")
+
+        test_result = frame.EvaluateExpression("fun_var")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 9, "fun_var = 9")
+
+        test_result = frame.EvaluateExpression("not_imported")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 35, "not_imported = 35")
+
+        test_result = frame.EvaluateExpression("imported")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 99, "imported = 99")
+
+        test_result = frame.EvaluateExpression("single")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 3, "single = 3")
+
+        # Continue to second breakpoint
+        process.Continue()
+
+        # Get the thread of the process
+        self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+
+        # Get current fream of the thread at the breakpoint
+        frame = thread.GetSelectedFrame()
+
+        # Test function inside namespace
+        test_result = frame.EvaluateExpression("fun_var")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 5, "fun_var = 5")
+        
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/lang/cpp/nsimport/main.cpp

 namespace Nested
 {
     namespace
     {
         int nested;
     }
 }
 
-using namespace N;
-using namespace Nested;
+namespace Global
+{
+    int global;
+}
+
+namespace Fun
+{
+    int fun_var;
+    int fun()
+    {
+        fun_var = 5;
+        return 0; // break 1
+    }
+}
+
+namespace Single
+{
+    int single = 3;
+}
+
+namespace NotImportedBefore
+{
+    int not_imported = 45;
+}
+
+using namespace Global;
+
+int not_imported = 35;
+int fun_var = 9;
+
+namespace NotImportedAfter
+{
+    int not_imported = 55;
+}
+
+namespace Imported
+{
+    int imported = 99;
+}
+
+int imported = 89;
 
 int main()
 {
+    using namespace N;
+    using namespace Nested;
+    using namespace Imported;
+    using Single::single;
     n = 1;
     anon = 2;
     nested = 3;
-    return 0; // break 0
+    global = 4;
+    return Fun::fun(); // break 0
 }