Top-level anonymous namespaces are missing import DW_TAG_imported_module and nested anonymous namespaces are not

[kromanova]

Summary

I had a review opened for anonymous namespaces bug in llvm-commits (see http://reviews.llvm.org/D7895). It was opened in llvm-commits is because the first patch that I submitted was in the backend. However it seems that the frontend patch will be more appropriate in this case. David Blaikie advised to get cfe developers opinion, specifically Richard Smith's.
Rather than just adding cfe-dev to the reviewers list, I thought it will be better to open a brand new review.

There was quite a long discussion in llvm-commits list about this bug and several re-implementations of a fix, so it gets confusing after a while.
I will write a short summary of what was discussed in http://reviews.llvm.org/D7895

Problem #1:

DW_TAG_imported_module is missing from the compile unit's root scope. Without this tag, anonymous namespace is not imported into the root scope by PS4 debugger.

Consider the following testcase. Lack of DW_TAG_imported_module prevents our debugger from displaying the value of ‘a’.

#include <stdio.h>

namespace
{

int a = 5;

}

int main()
{

printf("%d\n", a);

return 0;

}

Problem #2:

Another (more general) problem is that while the clang compiler doesn't generate DW_TAG_imported_module for the top-level anonymous namespace, it generates this tag for nested anonymous namespaces. So, we have an asymmetrical situation.

namespace
{

namespace {
  int a1 = 5;
}
int a2 = 7;

}
int *b1 = &a1;
int *b2 = &a2;

DWARF:
<1><54>: Abbrev Number: 5 (DW_TAG_namespace)

<55>   DW_AT_decl_file   : 1
<56>   DW_AT_decl_line   : 2

<2><57>: Abbrev Number: 5 (DW_TAG_namespace)

<58>   DW_AT_decl_file   : 1
<59>   DW_AT_decl_line   : 3

....
<2><8d>: Abbrev Number: 7 (DW_TAG_imported_module)

<8e>   DW_AT_import      : <0x57>   [Abbrev Number: 5 (DW_TAG_namespace)]

Note that DW_TAG_import is not generated for the top-level anonymous namespace.

There was a long discussion if we want to generate explicit imports marked by DW_AT_artificial attribute for anonymous namespaces in Clang or not. Both GCC and ICC compilers generate explicit imports in this case. However, it's an arguable gray area between the compiler and the debugger. The final decision was *not* to generate DW_TAG_imported_module for all the platforms except PS4. On PS4 we definitely want it, since our debugger doesn't import the anonymous namespace automatically.

There were several different patches for this fix. For this review, I'm providing the latest FE patch only. It takes care of both problem #1 and problem #2.
See http://reviews.llvm.org/D7895 for more details/earlier patches.

Richard, could you please give your opinion on how that problem needs to get taken care of in the FE. I don't mind re-writing patch based on your comments, if necessary.
Thank you!

[rsmith]

I think this is fundamentally the right approach. Anonymous namespaces do inject a using directive, and we should not forget to pass it to the AST consumer.

lib/CodeGen/CGDebugInfo.cpp

3263–3264

I think we should do this unconditionally, to better match the source language semantics, but I'm curious what David, Eric, and other folks on the DWARF side think.

lib/Parse/ParseDeclCXX.cpp

204

This comment doesn't add anything and doesn't use the right name for either variable. Just remove it?

235

Use nullptr, not NULL.

241

Add an assert here:

assert(!ImplicitUsingDirectiveDecl && "nested namespace definition cannot define anonymous namespace");

lib/Sema/SemaDeclCXX.cpp

7189

No space after &.

[probinson]

lib/CodeGen/CGDebugInfo.cpp

3263–3264

David (in previous discussions and review comments) has said he thinks it is unnecessary as the debugger already must know so much about C++ to get various things right, it might as well know that it has to implicitly import the anonymous namespace contents. One example debugger UI allows the user to type source-like syntax, and requires the debugger to apply (for example) C++ parameter-type matching rules to distinguish between overloaded functions. Compared to this, implicit imports are child's play.

I believe Eric agrees with David; I don't remember whether Adrian said anything in the previous iterations of this patch.

I believe the explicit (although artificial) import is a good thing, because it matches the source language semantics. I find an important distinction between "which declarations are available in this scope" and "how does the user disambiguate declarations in this scope." As a counterpart to the above debugger UI example, I postulate a GUI drop-down list of symbols available in-scope; this UI needs to know nothing about language semantics and automatic imports, if the DWARF provides the correct explicit import. This suggests to me that the DWARF should provide it.

There's also the piddly detail that debuggers are not the only consumers of DWARF information, and presenting the DWARF in a more source-language-neutral way (i.e., with the explicit artificial import) could be beneficial for those other consumers, who might not necessarily want to learn language-specific scoping rules.

No debugger will be thrown for a loop if it sees the explicit import; however for some debuggers it would be redundant (because they implicitly import the anonymous namespace already). There is a pretty trivial space savings if it's omitted.

Katya has mentioned the GCC and ICC precedent; in fairness I will say GCC didn't used to emit this, and GDB tolerated that.

Note that the DWARF standard does not tell us what to do; it merely tells us how to emit the import, if we want to emit one. Whether we want to emit one is up to us.

[rsmith]

lib/CodeGen/CGDebugInfo.cpp

3263–3264

I've chatted to David about this offline, and he said largely similar things. It seems that different DWARF consumers will want and expect different things here, so (sadly) we should do different things depending on who we think will be consuming the DWARF.

I'm fine keeping this conditional, but I don't think IR generation should be making this decision based on the triple, so I'd prefer it was phrased in a different way: add a CodeGenOpt for whether to emit imports for anonymous namespaces, and enable it for PS4 targets from the frontend.

[probinson]

lib/CodeGen/CGDebugInfo.cpp

3263–3264

I think including the explicit import is not actively harmful to any consumer, or to object-file size; but if somebody insists on not having it, okay.

Assuming Katya is willing to invent the CodeGenOpt, I should add that not too far down on my to-do list is plumbing the LLVM "debugger tuning" idea up through Clang. We can make the tuning (rather than the triple) set the CodeGenOpt when the time comes.

[probinson]

This seems pretty fine-grained for a CodeGenOpt (not that I've looked there, perhaps there are examples of similarly fine grained things already there?)- I'm curious to understand the preference towards that rather than perhaps the more general "Debugger tuning" sort of thing Paul's implemented/could be pushed up here.

On the LLVM side, debugger tuning is basically a way to package up settings for a variety of rather specific flags. Then the individual flags control their respective fine-grained behaviors. This approach was very clearly favored during the whole "what is tuning" design discussion.

So, having an "emit explicit import" flag follows that same design decision and makes rather more sense than peppering IRGen with tuning or triple checks. Whether the flag goes in CodeGenOpt or somewhere else is a separate question. There are other debug-related flags in there, but if they want to be factored out into their own DebugInfoOpt that's probably a separate topic/patch.
--paulr

From: David Blaikie [mailto:[e-mail]]
Sent: Tuesday, September 08, 2015 7:36 PM
To: [e-mail]; Richard Smith
Cc: Romanova, Katya; Eric Christopher; Robinson, Paul; Adrian Prantl; cfe-commits
Subject: Re: [PATCH] D12624: Top-level anonymous namespaces are missing import DW_TAG_imported_module and nested anonymous namespaces are not

[kromanova]

I have made all the changes that Richard suggested. Sorry for the delay, got distracted by other tasks.
Anything else I need to change?

[rsmith]

This looks good to me.

Once we have this in place we can think about factoring the debug-specific flags out of CodeGenOpts into some kind of DebugInfoOpts, to be configured by whatever debugger tuning mechanism we end up with.

[kromanova]

Once we have this in place we can think about factoring the debug-specific flags out of CodeGenOpts into some kind of DebugInfoOpts, to be configured by whatever debugger tuning mechanism we end up with.

Good idea!
Thank you for such prompt review.
Katya.

include/clang/Frontend/CodeGenOptions.def

 VALUE_CODEGENOPT(StackProbeSize    , 32, 4096) ///< Overrides default stack
                                                ///< probe size, even if 0.
 CODEGENOPT(DebugColumnInfo, 1, 0) ///< Whether or not to use column information
                                   ///< in debug info.
 
 CODEGENOPT(DebugTypeExtRefs, 1, 0) ///< Whether or not debug info should contain
                                    ///< external references to a PCH or module.
 
+CODEGENOPT(DebugExplicitImport, 1, 0)  ///< Whether or not debug info should 
+                                       ///< contain explicit imports for 
+                                       ///< anonymous namespaces
+
 CODEGENOPT(EmitLLVMUseLists, 1, 0) ///< Control whether to serialize use-lists.
 
 /// The user specified number of registers to be used for integral arguments,
 /// or 0 if unspecified.
 VALUE_CODEGENOPT(NumRegisterParameters, 32, 0)
 
 /// The lower bound for a buffer to be considered for stack protection.
 VALUE_CODEGENOPT(SSPBufferSize, 32, 0)

include/clang/Parse/Parser.h

enum CXX11AttributeKind {
     CAK_InvalidAttributeSpecifier
   };
   CXX11AttributeKind
   isCXX11AttributeSpecifier(bool Disambiguate = false,
                             bool OuterMightBeMessageSend = false);
 
   void DiagnoseUnexpectedNamespace(NamedDecl *Context);
 
-  Decl *ParseNamespace(unsigned Context, SourceLocation &DeclEnd,
+  DeclGroupPtrTy ParseNamespace(unsigned Context, SourceLocation &DeclEnd,
                                 SourceLocation InlineLoc = SourceLocation());
   void ParseInnerNamespace(std::vector<SourceLocation>& IdentLoc,
                            std::vector<IdentifierInfo*>& Ident,
                            std::vector<SourceLocation>& NamespaceLoc,
                            unsigned int index, SourceLocation& InlineLoc,
                            ParsedAttributes& attrs,
                            BalancedDelimiterTracker &Tracker);
   Decl *ParseLinkage(ParsingDeclSpec &DS, unsigned Context);
   Decl *ParseUsingDirectiveOrDeclaration(unsigned Context,

include/clang/Sema/Sema.h

public:
   //===---------------------------- C++ Features --------------------------===//
 
   // Act on C++ namespaces
   Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,
                                SourceLocation NamespaceLoc,
                                SourceLocation IdentLoc,
                                IdentifierInfo *Ident,
                                SourceLocation LBrace,
-                               AttributeList *AttrList);
+                               AttributeList *AttrList,
+                               UsingDirectiveDecl * &UsingDecl);
   void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);
 
   NamespaceDecl *getStdNamespace() const;
   NamespaceDecl *getOrCreateStdNamespace();
 
   CXXRecordDecl *getStdBadAlloc() const;
 
   /// \brief Tests whether Ty is an instance of std::initializer_list and, if

lib/CodeGen/CGDebugInfo.cpp

void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
   llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields);
 
   llvm::DIType *type = DBuilder.createStructType(
       tunit, typeName.str(), tunit, line,
       CGM.getContext().toBits(block.BlockSize),
       CGM.getContext().toBits(block.BlockAlign), 0, nullptr, fieldsArray);
   type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
 
   // Get overall information about the block.
   unsigned flags = llvm::DINode::FlagArtificial;
   auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
 
   // Create the descriptor for the parameter.
   auto *debugVar = DBuilder.createParameterVariable(
       scope, Arg->getName(), ArgNo, tunit, line, type,
       CGM.getLangOpts().Optimize, flags);
 
   if (LocalAddr) {
if (!LexicalBlockStack.empty())
     return LexicalBlockStack.back();
   llvm::DIScope *Mod = getParentModuleOrNull(D);
   return getContextDescriptor(D, Mod ? Mod : TheCU);
 }
 
 void CGDebugInfo::EmitUsingDirective(const UsingDirectiveDecl &UD) {
   if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
     return;
+  const NamespaceDecl *NSDecl = UD.getNominatedNamespace();
+  if (!NSDecl->isAnonymousNamespace() || 
+      CGM.getCodeGenOpts().DebugExplicitImport) { 
     DBuilder.createImportedModule(
         getCurrentContextDescriptor(cast<Decl>(UD.getDeclContext())),
-      getOrCreateNameSpace(UD.getNominatedNamespace()),
+        getOrCreateNameSpace(NSDecl),
         getLineNumber(UD.getLocation()));
   }
+}
 
 void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) {
   if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
     return;
   assert(UD.shadow_size() &&
          "We shouldn't be codegening an invalid UsingDecl containing no decls");
   // Emitting one decl is sufficient - debuggers can detect that this is an
   // overloaded name & provide lookup for all the overloads.

lib/Frontend/CompilerInvocation.cpp

static void parseSanitizerKinds(StringRef FlagName,
   }
 }
 
 static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
                              DiagnosticsEngine &Diags,
                              const TargetOptions &TargetOpts) {
   using namespace options;
   bool Success = true;
+  llvm::Triple Triple = llvm::Triple(TargetOpts.Triple);
 
   unsigned OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
   // TODO: This could be done in Driver
   unsigned MaxOptLevel = 3;
   if (OptimizationLevel > MaxOptLevel) {
     // If the optimization level is not supported, fall back on the default
     // optimization
     Diags.Report(diag::warn_drv_optimization_value)
Opts.setDebugInfo(
             .Case("limited", CodeGenOptions::LimitedDebugInfo)
             .Case("standalone", CodeGenOptions::FullDebugInfo));
   }
   Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags);
   Opts.DebugColumnInfo = Args.hasArg(OPT_dwarf_column_info);
   Opts.EmitCodeView = Args.hasArg(OPT_gcodeview);
   Opts.SplitDwarfFile = Args.getLastArgValue(OPT_split_dwarf_file);
   Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs);
+  if (Triple.isPS4CPU())
+    Opts.DebugExplicitImport = true;
 
   for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ))
     Opts.DebugPrefixMap.insert(StringRef(Arg).split('='));
 
   if (const Arg *A =
           Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))
     Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;
 

lib/Parse/ParseDecl.cpp

case tok::kw_export:
     ProhibitAttributes(attrs);
     SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd);
     break;
   case tok::kw_inline:
     // Could be the start of an inline namespace. Allowed as an ext in C++03.
     if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_namespace)) {
       ProhibitAttributes(attrs);
       SourceLocation InlineLoc = ConsumeToken();
-      SingleDecl = ParseNamespace(Context, DeclEnd, InlineLoc);
-      break;
+      return ParseNamespace(Context, DeclEnd, InlineLoc);
     }
     return ParseSimpleDeclaration(Context, DeclEnd, attrs,
                                   true);
   case tok::kw_namespace:
     ProhibitAttributes(attrs);
-    SingleDecl = ParseNamespace(Context, DeclEnd);
-    break;
+    return ParseNamespace(Context, DeclEnd);
   case tok::kw_using:
     SingleDecl = ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(),
                                                   DeclEnd, attrs, &OwnedType);
     break;
   case tok::kw_static_assert:
   case tok::kw__Static_assert:
     ProhibitAttributes(attrs);
     SingleDecl = ParseStaticAssertDeclaration(DeclEnd);

lib/Parse/ParseDeclCXX.cpp

 ///
 ///       extension-namespace-definition:
 ///         'inline'[opt] 'namespace' original-namespace-name
 ///             '{' namespace-body '}'
 ///
 ///       namespace-alias-definition:  [C++ 7.3.2: namespace.alias]
 ///         'namespace' identifier '=' qualified-namespace-specifier ';'
 ///
-Decl *Parser::ParseNamespace(unsigned Context,
+Parser::DeclGroupPtrTy Parser::ParseNamespace(unsigned Context,
                                               SourceLocation &DeclEnd,
                                               SourceLocation InlineLoc) {
   assert(Tok.is(tok::kw_namespace) && "Not a namespace!");
   SourceLocation NamespaceLoc = ConsumeToken();  // eat the 'namespace'.
   ObjCDeclContextSwitch ObjCDC(*this);
     
   if (Tok.is(tok::code_completion)) {
     Actions.CodeCompleteNamespaceDecl(getCurScope());
     cutOffParsing();
-    return nullptr;
+    return DeclGroupPtrTy();;
   }
 
   SourceLocation IdentLoc;
   IdentifierInfo *Ident = nullptr;
   std::vector<SourceLocation> ExtraIdentLoc;
   std::vector<IdentifierInfo*> ExtraIdent;
   std::vector<SourceLocation> ExtraNamespaceLoc;
 
if (Tok.is(tok::kw___attribute)) {
     ParseGNUAttributes(attrs);
   }
 
   if (Tok.is(tok::equal)) {
     if (!Ident) {
       Diag(Tok, diag::err_expected) << tok::identifier;
       // Skip to end of the definition and eat the ';'.
       SkipUntil(tok::semi);
-      return nullptr;
+      return DeclGroupPtrTy();
     }
     if (attrLoc.isValid())
       Diag(attrLoc, diag::err_unexpected_namespace_attributes_alias);
     if (InlineLoc.isValid())
       Diag(InlineLoc, diag::err_inline_namespace_alias)
           << FixItHint::CreateRemoval(InlineLoc);
-    return ParseNamespaceAlias(NamespaceLoc, IdentLoc, Ident, DeclEnd);
-  }
+    Decl *NSAlias = ParseNamespaceAlias(NamespaceLoc, IdentLoc, Ident, DeclEnd);
+    return Actions.ConvertDeclToDeclGroup(NSAlias);
 
   BalancedDelimiterTracker T(*this, tok::l_brace);
   if (T.consumeOpen()) {
     if (Ident)
       Diag(Tok, diag::err_expected) << tok::l_brace;
     else
       Diag(Tok, diag::err_expected_either) << tok::identifier << tok::l_brace;
-    return nullptr;
+    return DeclGroupPtrTy();
   }
 
   if (getCurScope()->isClassScope() || getCurScope()->isTemplateParamScope() || 
       getCurScope()->isInObjcMethodScope() || getCurScope()->getBlockParent() || 
       getCurScope()->getFnParent()) {
     Diag(T.getOpenLocation(), diag::err_namespace_nonnamespace_scope);
     SkipUntil(tok::r_brace);
-    return nullptr;
+    return DeclGroupPtrTy();
   }
 
   if (ExtraIdent.empty()) {
     // Normal namespace definition, not a nested-namespace-definition.
   } else if (InlineLoc.isValid()) {
     Diag(InlineLoc, diag::err_inline_nested_namespace_definition);
   } else if (getLangOpts().CPlusPlus1z) {
     Diag(ExtraNamespaceLoc[0],
Parser::DeclGroupPtrTy Parser::ParseNamespace(unsigned Context,
   // If we're still good, complain about inline namespaces in non-C++0x now.
   if (InlineLoc.isValid())
     Diag(InlineLoc, getLangOpts().CPlusPlus11 ?
          diag::warn_cxx98_compat_inline_namespace : diag::ext_inline_namespace);
 
   // Enter a scope for the namespace.
   ParseScope NamespaceScope(this, Scope::DeclScope);
 
+  UsingDirectiveDecl *ImplicitUsingDirectiveDecl = nullptr;
   Decl *NamespcDecl =
     Actions.ActOnStartNamespaceDef(getCurScope(), InlineLoc, NamespaceLoc,
                                    IdentLoc, Ident, T.getOpenLocation(), 
-                                   attrs.getList());
+                                   attrs.getList(), ImplicitUsingDirectiveDecl);
 
   PrettyDeclStackTraceEntry CrashInfo(Actions, NamespcDecl, NamespaceLoc,
                                       "parsing namespace");
 
   // Parse the contents of the namespace.  This includes parsing recovery on 
   // any improperly nested namespaces.
   ParseInnerNamespace(ExtraIdentLoc, ExtraIdent, ExtraNamespaceLoc, 0,
                       InlineLoc, attrs, T);
 
   // Leave the namespace scope.
   NamespaceScope.Exit();
 
   DeclEnd = T.getCloseLocation();
   Actions.ActOnFinishNamespaceDef(NamespcDecl, DeclEnd);
   
-  return NamespcDecl;
+  return Actions.ConvertDeclToDeclGroup(NamespcDecl, 
+                                        ImplicitUsingDirectiveDecl);
 }
 
 /// ParseInnerNamespace - Parse the contents of a namespace.
 void Parser::ParseInnerNamespace(std::vector<SourceLocation> &IdentLoc,
                                  std::vector<IdentifierInfo *> &Ident,
                                  std::vector<SourceLocation> &NamespaceLoc,
                                  unsigned int index, SourceLocation &InlineLoc,
                                  ParsedAttributes &attrs,
if (index == Ident.size()) {
 
     return;
   }
 
   // Handle a nested namespace definition.
   // FIXME: Preserve the source information through to the AST rather than
   // desugaring it here.
   ParseScope NamespaceScope(this, Scope::DeclScope);
+  UsingDirectiveDecl *ImplicitUsingDirectiveDecl = nullptr;
   Decl *NamespcDecl =
     Actions.ActOnStartNamespaceDef(getCurScope(), SourceLocation(),
                                    NamespaceLoc[index], IdentLoc[index],
                                    Ident[index], Tracker.getOpenLocation(), 
-                                   attrs.getList());
+                                   attrs.getList(), ImplicitUsingDirectiveDecl);
+  assert(!ImplicitUsingDirectiveDecl && 
+         "nested namespace definition cannot define anonymous namespace");
 
   ParseInnerNamespace(IdentLoc, Ident, NamespaceLoc, ++index, InlineLoc,
                       attrs, Tracker);
 
   NamespaceScope.Exit();
-
   Actions.ActOnFinishNamespaceDef(NamespcDecl, Tracker.getCloseLocation());
 }
 
 /// ParseNamespaceAlias - Parse the part after the '=' in a namespace
 /// alias definition.
 ///
 Decl *Parser::ParseNamespaceAlias(SourceLocation NamespaceLoc,
                                   SourceLocation AliasLoc,

lib/Sema/SemaDeclCXX.cpp

 /// ActOnStartNamespaceDef - This is called at the start of a namespace
 /// definition.
 Decl *Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
                                    SourceLocation InlineLoc,
                                    SourceLocation NamespaceLoc,
                                    SourceLocation IdentLoc,
                                    IdentifierInfo *II,
                                    SourceLocation LBrace,
-                                   AttributeList *AttrList) {
+                                   AttributeList *AttrList,
+                                   UsingDirectiveDecl *&UD) {
   SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
   // For anonymous namespace, take the location of the left brace.
   SourceLocation Loc = II ? IdentLoc : LBrace;
   bool IsInline = InlineLoc.isValid();
   bool IsInvalid = false;
   bool IsStd = false;
   bool AddToKnown = false;
   Scope *DeclRegionScope = NamespcScope->getParent();
if (II) {
     // We just create the namespace with an empty name and then add an
     // implicit using declaration, just like the standard suggests.
     //
     // CodeGen enforces the "universally unique" aspect by giving all
     // declarations semantically contained within an anonymous
     // namespace internal linkage.
 
     if (!PrevNS) {
-      UsingDirectiveDecl* UD
-        = UsingDirectiveDecl::Create(Context, Parent,
+      UD = UsingDirectiveDecl::Create(Context, Parent,
                                       /* 'using' */ LBrace,
                                       /* 'namespace' */ SourceLocation(),
                                       /* qualifier */ NestedNameSpecifierLoc(),
                                       /* identifier */ SourceLocation(),
                                       Namespc,
                                       /* Ancestor */ Parent);
       UD->setImplicit();
       Parent->addDecl(UD);
     }
   }
 
   ActOnDocumentableDecl(Namespc);
 
   // Although we could have an invalid decl (i.e. the namespace name is a

test/CodeGenCXX/debug-info-anon-namespace.cpp

+// RUN: %clang_cc1 -emit-llvm -debug-info-kind=limited -triple x86_64-scei-ps4 -O0 %s -o - | FileCheck --check-prefix=PS4 %s
+// RUN: %clang_cc1 -emit-llvm -debug-info-kind=limited -triple x86_64-unknown-linux-gnu -O0 %s -o - | FileCheck --check-prefix=NON-PS4 %s
+
+namespace
+{
+  int a = 5;
+}
+int *b = &a;
+
+namespace
+{
+  namespace {
+    int a1 = 5;
+  }
+  int a2 = 7;
+}
+int *b1 = &a1;
+int *b2 = &a2;
+
+
+// PS4:  [[NS:![0-9]+]] = !DINamespace
+// PS4:  [[NS2:![0-9]+]] = !DINamespace
+// PS4: !DIImportedEntity(tag: DW_TAG_imported_module, scope: !0, entity: [[NS]])
+// PS4: !DIImportedEntity(tag: DW_TAG_imported_module, scope: [[NS]], entity: [[NS2]], line: {{[0-9]+}})
+// NON-PS4-NOT: !DIImportedEntity
+