Downgrade a number of FIXME asserts to ErrorUnsupported.

- Notably VLAs

llvm-svn: 55544

clang/lib/CodeGen/CGDecl.cpp

@@ -37,24 +37,20 @@ void CodeGenFunction::EmitDecl(const Decl &D) {
   case Decl::Union:     // union X;
   case Decl::Class:     // class X;
   case Decl::Enum:      // enum X;
+  case Decl::EnumConstant: // enum ? { X = ? } 
   case Decl::CXXStruct: // struct X; [C++]
   case Decl::CXXUnion:  // union X; [C++]
   case Decl::CXXClass:  // class X; [C++]
     // None of these decls require codegen support.
     return;
     
-  case Decl::Var:
-    if (cast<VarDecl>(D).isBlockVarDecl())
-      return EmitBlockVarDecl(cast<VarDecl>(D));
-    assert(0 && "Should not see file-scope variables inside a function!");
-  
-  case Decl::EnumConstant:
-    return EmitEnumConstantDecl(cast<EnumConstantDecl>(D));
+  case Decl::Var: {
+    const VarDecl &VD = cast<VarDecl>(D);
+    assert(VD.isBlockVarDecl() && 
+           "Should not see file-scope variables inside a function!");
+    return EmitBlockVarDecl(VD);
+  }
   }
-}
-
-void CodeGenFunction::EmitEnumConstantDecl(const EnumConstantDecl &D) {
-  assert(0 && "FIXME: Enum constant decls not implemented yet!");  
 }
 
 /// EmitBlockVarDecl - This method handles emission of any variable declaration
@@ -169,8 +165,13 @@ void CodeGenFunction::EmitLocalBlockVarDecl(const VarDecl &D) {
       DeclPtr = GenerateStaticBlockVarDecl(D, true, Class);
     }
   } else {
-    // TODO: Create a dynamic alloca.
-    assert(0 && "FIXME: Local VLAs not implemented yet");
+    CGM.ErrorUnsupported(&D, "variable-length array");
+
+    // FIXME: VLA: Add VLA support. For now just make up enough to let
+    // the compile go through.
+    const llvm::Type *LTy = ConvertType(Ty);
+    llvm::AllocaInst * Alloc = CreateTempAlloca(LTy, D.getName());
+    DeclPtr = Alloc;
   }
   
   llvm::Value *&DMEntry = LocalDeclMap[&D];

clang/lib/CodeGen/CGExprScalar.cpp

@@ -513,10 +513,14 @@ Value *ScalarExprEmitter::VisitImplicitCastExpr(const ImplicitCastExpr *E) {
     // will not true when we add support for VLAs.
     Value *V = EmitLValue(Op).getAddress();  // Bitfields can't be arrays.
     
-    assert(isa<llvm::PointerType>(V->getType()) &&
-           isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType())
-                                ->getElementType()) &&
-           "Doesn't support VLAs yet!");
+    if (!(isa<llvm::PointerType>(V->getType()) &&
+          isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType())
+                               ->getElementType()))) {
+      CGF.ErrorUnsupported(E, "variable-length array cast");
+      if (E->getType()->isVoidType())
+        return 0;
+      return llvm::UndefValue::get(CGF.ConvertType(E->getType()));
+    }
     V = Builder.CreateStructGEP(V, 0, "arraydecay");
     
     // The resultant pointer type can be implicitly casted to other pointer

clang/lib/CodeGen/CGObjCMac.cpp

@@ -1911,7 +1911,7 @@ llvm::Value *ObjCTypesHelper::getMessageSendFn(bool IsSuper,
     Params[1] = IsSuper ? SuperPtrTy : ObjectPtrTy;
     Params[2] = SelectorPtrTy;
     CallFTy = llvm::FunctionType::get(llvm::Type::VoidTy, Params, true);
-  } else { // XXX floating point?
+  } else { // FIXME: floating point?
     F = IsSuper ? MessageSendSuperFn : MessageSendFn;
     std::vector<const llvm::Type*> Params(2);
     Params[0] = IsSuper ? SuperPtrTy : ObjectPtrTy;

clang/lib/CodeGen/CGStmt.cpp

@@ -464,7 +464,7 @@ void CodeGenFunction::EmitContinueStmt() {
 /// add multiple cases to switch instruction, one for each value within
 /// the range. If range is too big then emit "if" condition check.
 void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) {
-  // XXX kill me with param - ddunbar
+  // FIXME: kill me with param - ddunbar
   assert(S.getRHS() && "Expected RHS value in CaseStmt");
 
   llvm::APSInt LHS = S.getLHS()->getIntegerConstantExprValue(getContext());
@@ -755,7 +755,7 @@ void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) {
         if (ConvertType(InputExpr->getType())->isSingleValueType()) {
           Arg = EmitScalarExpr(InputExpr);
         } else {
-          assert(0 && "FIXME: Implement passing multiple-value types as inputs");
+          ErrorUnsupported(&S, "asm statement passing multiple-value types as inputs");
         }
       } else {
         LValue Dest = EmitLValue(InputExpr);
@@ -796,7 +796,7 @@ void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) {
       if (ConvertType(InputExpr->getType())->isSingleValueType()) {
         Arg = EmitScalarExpr(InputExpr);
       } else {
-        assert(0 && "FIXME: Implement passing multiple-value types as inputs");
+        ErrorUnsupported(&S, "asm statement passing multiple-value types as inputs");
       }
     } else {
       LValue Dest = EmitLValue(InputExpr);

clang/lib/CodeGen/CodeGenFunction.h

@@ -198,7 +198,6 @@ public:
   //===--------------------------------------------------------------------===//
   
   void EmitDecl(const Decl &D);
-  void EmitEnumConstantDecl(const EnumConstantDecl &D);
   void EmitBlockVarDecl(const VarDecl &D);
   void EmitLocalBlockVarDecl(const VarDecl &D);
   void EmitStaticBlockVarDecl(const VarDecl &D);

clang/lib/CodeGen/CodeGenModule.cpp

@@ -764,7 +764,11 @@ GetAddrOfConstantCFString(const std::string &str) {
 /// GetStringForStringLiteral - Return the appropriate bytes for a
 /// string literal, properly padded to match the literal type.
 std::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) {
-  assert(!E->isWide() && "FIXME: Wide strings not supported yet!");
+  if (E->isWide()) {
+    ErrorUnsupported(E, "wide string");
+    return "FIXME";
+  }
+
   const char *StrData = E->getStrData();
   unsigned Len = E->getByteLength();
 
@@ -877,7 +881,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) {
     break;
 
   case Decl::Namespace:
-    assert(0 && "FIXME: Namespace unsupported");
+    ErrorUnsupported(D, "namespace");
     break;
 
     // Objective-C Decls
@@ -914,7 +918,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) {
     break;
   }
   case Decl::ObjCCompatibleAlias: 
-    assert(0 && "FIXME: ObjCCompatibleAlias unsupported");
+    ErrorUnsupported(D, "Objective-C compatible alias");
     break;
 
   case Decl::LinkageSpec: {