Put back the top-level asm code; all tests pass now.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@46868 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/AST/Decl.cpp b/AST/Decl.cpp
index 78916c53b7cecb9eff8c006eb92840c4b2b08e38..55abe6f34d5f60a0b9e7182a1c0c7eb2dbcbdbcb 100644 (file)
--- a/AST/Decl.cpp
+++ b/AST/Decl.cpp
@@ -38,6 +38,7 @@ static unsigned nObjCCategoryImpl = 0;
 static unsigned nObjCCompatibleAlias = 0;
 static unsigned nObjCPropertyDecl = 0;
 static unsigned nLinkageSpecDecl = 0;
+static unsigned nFileScopeAsmDecl = 0;
 
 static bool StatSwitch = false;
 
@@ -169,7 +170,8 @@ void Decl::PrintStats() {
               nObjCCategoryImpl*sizeof(ObjCCategoryImplDecl)+
               nObjCCompatibleAlias*sizeof(ObjCCompatibleAliasDecl)+
               nObjCPropertyDecl*sizeof(ObjCPropertyDecl)+
-              nLinkageSpecDecl*sizeof(LinkageSpecDecl)));
+              nLinkageSpecDecl*sizeof(LinkageSpecDecl)+
+              nFileScopeAsmDecl*sizeof(FileScopeAsmDecl)));
     
 }
 
@@ -240,6 +242,9 @@ void Decl::addDeclKind(const Kind k) {
     case LinkageSpec:
       nLinkageSpecDecl++;
       break;
+    case FileScopeAsm:
+      nFileScopeAsmDecl++;
+      break;
   }
 }
 

diff --git a/AST/DeclSerialization.cpp b/AST/DeclSerialization.cpp
index 146ebbacbe19331e43d57f300ca39f5a61453d7b..cb91846a027554211fd81252307ead3d1b702b43 100644 (file)
--- a/AST/DeclSerialization.cpp
+++ b/AST/DeclSerialization.cpp
@@ -67,6 +67,9 @@ Decl* Decl::Create(Deserializer& D) {
       
     case Typedef:
       return TypedefDecl::CreateImpl(D);
+      
+    case FileScopeAsm:
+      return FileScopeAsmDecl::CreateImpl(D);
   }
 }
 
@@ -438,3 +441,23 @@ void LinkageSpecDecl::ReadInRec(Deserializer& D) {
   Language = static_cast<LanguageIDs>(D.ReadInt());
   D.ReadPtr(this->D);
 }
+
+//===----------------------------------------------------------------------===//
+//      FileScopeAsm Serialization.
+//===----------------------------------------------------------------------===//
+
+void FileScopeAsmDecl::EmitImpl(llvm::Serializer& S) const
+{
+  Decl::EmitInRec(S);
+  S.EmitOwnedPtr(AsmString);
+}
+
+FileScopeAsmDecl* FileScopeAsmDecl::CreateImpl(Deserializer& D) { 
+  FileScopeAsmDecl* decl = new FileScopeAsmDecl(SourceLocation(), 0);
+
+  decl->Decl::ReadInRec(D);
+  decl->AsmString = cast<StringLiteral>(D.ReadOwnedPtr<Expr>());
+//  D.ReadOwnedPtr(D.ReadOwnedPtr<StringLiteral>())<#T * * Ptr#>, <#bool AutoRegister#>)(decl->AsmString);
+  
+  return decl;
+}

diff --git a/CodeGen/ModuleBuilder.cpp b/CodeGen/ModuleBuilder.cpp
index 50d6fedadd597f0afd4883f445bb18e0a743b2ee..06467488a5e945aec3974210c8ba72fba1a13105 100644 (file)
--- a/CodeGen/ModuleBuilder.cpp
+++ b/CodeGen/ModuleBuilder.cpp
@@ -70,6 +70,15 @@ namespace {
           Builder->WarnUnsupported(LSD, "linkage spec");
         // FIXME: implement C++ linkage, C linkage works mostly by C
         // language reuse already.
+      } else if (FileScopeAsmDecl *AD = dyn_cast<FileScopeAsmDecl>(D)) {
+        std::string AsmString(AD->getAsmString()->getStrData(),
+                              AD->getAsmString()->getByteLength());
+        
+        const std::string &S = Builder->getModule().getModuleInlineAsm();
+        if (S.empty())
+          Builder->getModule().setModuleInlineAsm(AsmString);
+        else
+          Builder->getModule().setModuleInlineAsm(S + '\n' + AsmString);
       } else {
         assert(isa<TypeDecl>(D) && "Unknown top level decl");
         // TODO: handle debug info?

diff --git a/Driver/ASTConsumers.cpp b/Driver/ASTConsumers.cpp
index 3868e7d75c3836535e35eef77ce44dd5e1cc0161..688619438b9de28e9afbeedefff0133c761d8f38 100644 (file)
--- a/Driver/ASTConsumers.cpp
+++ b/Driver/ASTConsumers.cpp
@@ -97,6 +97,10 @@ void DeclPrinter:: PrintDecl(Decl *D) {
     Out << "Read top-level variable decl: '" << SD->getName() << "'\n";
   } else if (LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(D)) {
     PrintLinkageSpec(LSD);
+  } else if (FileScopeAsmDecl *AD = dyn_cast<FileScopeAsmDecl>(D)) {
+    Out << "asm(";
+    AD->getAsmString()->printPretty(Out);
+    Out << ")\n";
   } else {
     assert(0 && "Unknown decl type!");
   }
@@ -402,6 +406,8 @@ namespace {
         Out << "Read objc fwd protocol decl\n";
       } else if (isa<ObjCClassDecl>(D)) {
         Out << "Read objc fwd class decl\n";
+      } else if (isa<FileScopeAsmDecl>(D)) {
+        Out << "Read file scope asm decl\n";
       } else {
         assert(0 && "Unknown decl type!");
       }

diff --git a/Parse/Parser.cpp b/Parse/Parser.cpp
index 6f2a71257a059d50bd2eeb65a3b51b5f33413bdc..e3208a0b3e959b5a1e8899dffd68cd5586addfae 100644 (file)
--- a/Parse/Parser.cpp
+++ b/Parse/Parser.cpp
@@ -320,12 +320,15 @@ Parser::DeclTy *Parser::ParseExternalDeclaration() {
     // FIXME: Restore extension warnings.
     return RV;
   }
-  case tok::kw_asm:
-    ParseSimpleAsm();
+  case tok::kw_asm: {
+    ExprResult Result = ParseSimpleAsm();
+    
     ExpectAndConsume(tok::semi, diag::err_expected_semi_after,
                      "top-level asm block");
-    // TODO: Invoke action for top-level asm.
-    return 0;
+
+    if (!Result.isInvalid)
+      return Actions.ActOnFileScopeAsmDecl(Tok.getLocation(), Result.Val);
+  }
   case tok::at:
     // @ is not a legal token unless objc is enabled, no need to check.
     return ParseObjCAtDirectives();
@@ -610,19 +613,21 @@ Parser::ExprResult Parser::ParseAsmStringLiteral() {
 /// [GNU] simple-asm-expr:
 ///         'asm' '(' asm-string-literal ')'
 ///
-void Parser::ParseSimpleAsm() {
+Parser::ExprResult Parser::ParseSimpleAsm() {
   assert(Tok.is(tok::kw_asm) && "Not an asm!");
-  ConsumeToken();
+  SourceLocation Loc = ConsumeToken();
   
   if (Tok.isNot(tok::l_paren)) {
     Diag(Tok, diag::err_expected_lparen_after, "asm");
-    return;
+    return 0;
   }
   
-  SourceLocation Loc = ConsumeParen();
+  ConsumeParen();
   
-  ParseAsmStringLiteral();
+  ExprResult Result = ParseAsmStringLiteral();
   
   MatchRHSPunctuation(tok::r_paren, Loc);
+  
+  return Result;
 }
 

diff --git a/Sema/Sema.h b/Sema/Sema.h
index 06a12e4f7f402f3e24b92546ccba4775d0ea8148..f3595e10767e5086969be7f89e63af841bbeff2e 100644 (file)
--- a/Sema/Sema.h
+++ b/Sema/Sema.h
@@ -197,7 +197,8 @@ private:
   virtual DeclTy *ActOnLinkageSpec(SourceLocation Loc, SourceLocation LBrace,
                                   SourceLocation RBrace, const char *Lang,
                                   unsigned StrSize, DeclTy *D);
-  
+  virtual DeclTy *ActOnFileScopeAsmDecl(SourceLocation Loc, ExprTy *expr);
+
   /// Scope actions.
   virtual void ActOnPopScope(SourceLocation Loc, Scope *S);
   virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S);

diff --git a/Sema/SemaDecl.cpp b/Sema/SemaDecl.cpp
index cd546f3efc5916363462fdb70b2a652a89dd5d45..00776912b0203faa3c83e31a7d0803c23f78eed7 100644 (file)
--- a/Sema/SemaDecl.cpp
+++ b/Sema/SemaDecl.cpp
@@ -1711,6 +1711,13 @@ void Sema::ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDeclX,
   Consumer.HandleTagDeclDefinition(Enum);
 }
 
+Sema::DeclTy *Sema::ActOnFileScopeAsmDecl(SourceLocation Loc,
+                                          ExprTy *expr) {
+  StringLiteral *AsmString = cast<StringLiteral>((Expr*)expr);
+  
+  return new FileScopeAsmDecl(Loc, AsmString);
+}
+
 Sema::DeclTy* Sema::ActOnLinkageSpec(SourceLocation Loc,
                                     SourceLocation LBrace,
                                     SourceLocation RBrace,

diff --git a/include/clang/AST/Decl.h b/include/clang/AST/Decl.h
index cc96b0732dffd736b97d18bd9680f09cdb622566..07588e4c06c312307b9bdfe52e36bcb3ca96e56a 100644 (file)
--- a/include/clang/AST/Decl.h
+++ b/include/clang/AST/Decl.h
@@ -27,6 +27,7 @@ class Decl;
 namespace clang {
 class Expr;
 class Stmt;
+class StringLiteral;
 class FunctionDecl;
 class IdentifierInfo;
 
@@ -71,6 +72,7 @@ public:
          ObjCClass,
          ObjCForwardProtocol,
         LinkageSpec,
+   FileScopeAsm,
   
     // For each non-leaf class, we now define a mapping to the first/last member
     // of the class, to allow efficient classof.
@@ -755,6 +757,27 @@ protected:
   friend Decl* Decl::Create(llvm::Deserializer& D);
 };
 
+class FileScopeAsmDecl : public Decl {
+  StringLiteral *AsmString;
+public:
+  FileScopeAsmDecl(SourceLocation L, StringLiteral *asmstring)
+    : Decl(FileScopeAsm, L), AsmString(asmstring) {}
+
+  const StringLiteral *getAsmString() const { return AsmString; }
+  StringLiteral *getAsmString() { return AsmString; }
+  static bool classof(const Decl *D) {
+    return D->getKind() == FileScopeAsm;
+  }
+  static bool classof(const FileScopeAsmDecl *D) { return true; }  
+protected:
+  /// EmitImpl - Serialize this FileScopeAsmDecl. Called by Decl::Emit.
+  virtual void EmitImpl(llvm::Serializer& S) const;
+  
+  /// CreateImpl - Deserialize a FileScopeAsmDecl.  Called by Decl::Create.
+  static FileScopeAsmDecl* CreateImpl(llvm::Deserializer& D);
+  
+  friend Decl* Decl::Create(llvm::Deserializer& D);
+};
 
 /// LinkageSpecDecl - This represents a linkage specification.  For example:
 ///   extern "C" void foo();

diff --git a/include/clang/Parse/Action.h b/include/clang/Parse/Action.h
index 7a2081978d5dba08e6c0936bc4fe1c101def4958..003dd9e01b90e8f5be58392ac3a1531bc2420505 100644 (file)
--- a/include/clang/Parse/Action.h
+++ b/include/clang/Parse/Action.h
@@ -141,6 +141,10 @@ public:
     return Decl;
   }
 
+  virtual DeclTy *ActOnFileScopeAsmDecl(SourceLocation Loc, ExprTy *AsmString) {
+    return 0;
+  }
+  
   /// ActOnPopScope - This callback is called immediately before the specified
   /// scope is popped and deleted.
   virtual void ActOnPopScope(SourceLocation Loc, Scope *S) {}

diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h
index 2712daa2453d94d3136e71fd2be233ad8e33d225..1987e964ecf28654340235c933f43eb4d2892f6b 100644 (file)
--- a/include/clang/Parse/Parser.h
+++ b/include/clang/Parse/Parser.h
@@ -256,7 +256,7 @@ private:
   DeclTy *ParseDeclarationOrFunctionDefinition();
   DeclTy *ParseFunctionDefinition(Declarator &D);
   void ParseKNRParamDeclarations(Declarator &D);
-  void ParseSimpleAsm();
+  ExprResult ParseSimpleAsm();
   ExprResult ParseAsmStringLiteral();
 
   // Objective-C External Declarations