Start stubbing out decl codegen.

llvm-svn: 39550

clang/CodeGen/CGDecl.cpp

@@ -0,0 +1,56 @@
+//===--- CGDecl.cpp - Emit LLVM Code for declarations ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Chris Lattner and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This contains code to emit Decl nodes as LLVM code.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CodeGenFunction.h"
+#include "clang/AST/AST.h"
+//#include "llvm/Constants.h"
+//#include "llvm/DerivedTypes.h"
+//#include "llvm/Function.h"
+using namespace llvm;
+using namespace clang;
+using namespace CodeGen;
+
+
+void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) {
+  const Decl *Decl = S.getDecl();
+
+  switch (Decl->getKind()) {
+  default: assert(0 && "Unknown decl kind!");
+  case Decl::FileVariable:
+    assert(0 && "Should not see file-scope variables inside a function!");
+  case Decl::ParmVariable:
+    assert(0 && "Parmdecls should not be in declstmts!");
+  case Decl::Typedef:   // typedef int X;
+  case Decl::Function:  // void X();
+  case Decl::Struct:    // struct X;
+  case Decl::Union:     // union X;
+  case Decl::Class:     // class X;
+  case Decl::Enum:      // enum X;
+    // None of these decls require codegen support.
+    return;
+    
+  case Decl::BlockVariable:
+    return EmitBlockVarDecl(cast<BlockVarDecl>(*Decl));
+  case Decl::EnumConstant:
+    return EmitEnumConstantDecl(cast<EnumConstantDecl>(*Decl));
+  }
+}
+
+void CodeGenFunction::EmitBlockVarDecl(const BlockVarDecl &D) {
+  //assert(0 && "FIXME: Enum constant decls not implemented yet!");  
+  
+}
+
+void CodeGenFunction::EmitEnumConstantDecl(const EnumConstantDecl &D) {
+  assert(0 && "FIXME: Enum constant decls not implemented yet!");  
+}

clang/CodeGen/CGStmt.cpp

@@ -44,6 +44,7 @@ void CodeGenFunction::EmitStmt(const Stmt *S) {
   case Stmt::GotoStmtClass:     EmitGotoStmt(cast<GotoStmt>(*S));         break;
   case Stmt::IfStmtClass:       EmitIfStmt(cast<IfStmt>(*S));             break;
   case Stmt::ReturnStmtClass:   EmitReturnStmt(cast<ReturnStmt>(*S));     break;
+  case Stmt::DeclStmtClass:     EmitDeclStmt(cast<DeclStmt>(*S));         break;
   }
 }
 

clang/CodeGen/CodeGenFunction.cpp

@@ -126,6 +126,9 @@ void CodeGenFunction::GenerateCode(const FunctionDecl *FD) {
   
   Builder.SetInsertPoint(EntryBB);
   
+  // TODO: handle params. 
+  
+  // Emit the function body.
   EmitStmt(FD->getBody());
   
   // Emit a return for code that falls off the end.

clang/CodeGen/CodeGenFunction.h

@@ -21,21 +21,26 @@ namespace llvm {
   class Module;
 namespace clang {
   class ASTContext;
+  class Decl;
   class FunctionDecl;
   class QualType;
   class SourceLocation;
   class TargetInfo;
+  
   class Stmt;
   class CompoundStmt;
   class LabelStmt;
   class GotoStmt;
   class IfStmt;
   class ReturnStmt;
+  class DeclStmt;
   
   class Expr;
   class IntegerLiteral;
   class BinaryOperator;
   
+  class BlockVarDecl;
+  class EnumConstantDecl;
 namespace CodeGen {
   class CodeGenModule;
   
@@ -85,6 +90,10 @@ class CodeGenFunction {
   const FunctionDecl *CurFuncDecl;
   llvm::Function *CurFn;
 
+  /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
+  /// decls.
+  DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
+
   /// LabelMap - This keeps track of the LLVM basic block for each C label.
   DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap;
 public:
@@ -101,7 +110,16 @@ public:
   
   
   void EmitBlock(BasicBlock *BB);
+
   
+  //===--------------------------------------------------------------------===//
+  //                        Local Declaration Emission
+  //===--------------------------------------------------------------------===//
+  
+  void EmitDeclStmt(const DeclStmt &S);
+  void EmitBlockVarDecl(const BlockVarDecl &D);
+  void EmitEnumConstantDecl(const EnumConstantDecl &D);
+
   //===--------------------------------------------------------------------===//
   //                             Statement Emission
   //===--------------------------------------------------------------------===//