void* operator new(size_t bytes) throw() {
llvm_unreachable("Attrs cannot be allocated with regular 'new'.");
- return 0;
}
void operator delete(void* data) throw() {
llvm_unreachable("Attrs cannot be released with regular 'delete'.");
protected:
void* operator new(size_t bytes) throw() {
llvm_unreachable("Stmts cannot be allocated with regular 'new'.");
- return 0;
}
void operator delete(void* data) throw() {
llvm_unreachable("Stmts cannot be released with regular 'delete'.");
// Silence GCC warning
llvm_unreachable("Unhandled template argument kind");
- return TemplateArgument();
}
NestedNameSpecifier *
}
llvm_unreachable("Unhandled TargetInfo::IntType value");
- return CanQualType();
}
//===----------------------------------------------------------------------===//
#define DEPENDENT_TYPE(Class, Base) case Type::Class:
#include "clang/AST/TypeNodes.def"
llvm_unreachable("Non-canonical and dependent types shouldn't get here");
- return QualType();
case Type::LValueReference:
case Type::RValueReference:
case Type::MemberPointer:
llvm_unreachable("C++ should never be in mergeTypes");
- return QualType();
case Type::ObjCInterface:
case Type::IncompleteArray:
case Type::FunctionProto:
case Type::ExtVector:
llvm_unreachable("Types are eliminated above");
- return QualType();
case Type::Pointer:
{
return UnsignedInt128Ty;
default:
llvm_unreachable("Unexpected signed integer type");
- return QualType();
}
}
return createMicrosoftMangleContext(*this, getDiagnostics());
}
llvm_unreachable("Unsupported ABI");
- return 0;
}
CXXABI::~CXXABI() {}
return TK_DependentFunctionTemplateSpecialization;
llvm_unreachable("Did we miss a TemplateOrSpecialization type?");
- return TK_NonTemplate;
}
FunctionDecl *FunctionDecl::getInstantiatedFromMemberFunction() const {
return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D));
#include "clang/AST/DeclNodes.inc"
llvm_unreachable("a decl that inherits DeclContext isn't handled");
- return 0;
}
}
return static_cast<NAME##Decl*>(const_cast<Decl*>(D));
#include "clang/AST/DeclNodes.inc"
llvm_unreachable("a decl that inherits DeclContext isn't handled");
- return 0;
}
}
default:
case AS_none:
llvm_unreachable("Invalid access specifier!");
- return 0;
case AS_public:
return "public";
case AS_private:
assert(!isa<ObjCProtocolDecl>(getDeclContext()) && "It's a protocol method");
llvm_unreachable("unknown method context");
- return 0;
}
//===----------------------------------------------------------------------===//
case ObjCCategoryImpl:
case ObjCProtocol:
llvm_unreachable("invalid ivar container!");
- return 0;
// Ivars can only appear in class extension categories.
case ObjCCategory: {
void DeclPrinter::Print(AccessSpecifier AS) {
switch(AS) {
- case AS_none: llvm_unreachable("No access specifier!"); break;
+ case AS_none: llvm_unreachable("No access specifier!");
case AS_public: Out << "public"; break;
case AS_protected: Out << "protected"; break;
case AS_private: Out << "private"; break;
// Can't actually get here.
llvm_unreachable("This should be unreachable!");
- return Identifier;
}
bool DeclarationName::isDependentName() const {
default:
llvm_unreachable("Declaration name has no FETokenInfo");
}
- return 0;
}
void DeclarationName::setFETokenInfo(void *T) {
return NameLoc;
}
llvm_unreachable("Unexpected declaration name kind");
- return SourceLocation();
}
switch (NPC) {
case NPC_NeverValueDependent:
llvm_unreachable("Unexpected value dependent expression!");
- // If the unthinkable happens, fall through to the safest alternative.
-
case NPC_ValueDependentIsNull:
if (isTypeDependent() || getType()->isIntegralType(Ctx))
return NPCK_ZeroInteger;
RetTy VisitStmt(const Stmt *) {
llvm_unreachable("Expression evaluator should not be called on stmts");
- return DerivedError(0);
}
RetTy VisitExpr(const Expr *E) {
return DerivedError(E);
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
llvm_unreachable("Can't mangle Objective-C selector names here!");
- break;
case DeclarationName::CXXConstructorName:
if (ND == Structor)
case DeclarationName::CXXUsingDirective:
llvm_unreachable("Can't mangle a using directive name!");
- break;
}
}
case OO_None:
case NUM_OVERLOADED_OPERATORS:
llvm_unreachable("Not an overloaded operator");
- break;
}
}
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
llvm_unreachable("Can't mangle Objective-C selector names here!");
- break;
case DeclarationName::CXXConstructorName:
llvm_unreachable("Can't mangle constructors yet!");
- break;
case DeclarationName::CXXDestructorName:
llvm_unreachable("Can't mangle destructors yet!");
- break;
case DeclarationName::CXXConversionFunctionName:
// <operator-name> ::= ?B # (cast)
case DeclarationName::CXXLiteralOperatorName:
// FIXME: Was this added in VS2010? Does MS even know how to mangle this?
llvm_unreachable("Don't know how to mangle literal operators yet!");
- break;
case DeclarationName::CXXUsingDirective:
llvm_unreachable("Can't mangle a using directive name!");
- break;
}
}
case OO_Conditional:
llvm_unreachable("Don't know how to mangle ?:");
- break;
case OO_None:
case NUM_OVERLOADED_OPERATORS:
llvm_unreachable("Not an overloaded operator");
- break;
}
}
case BuiltinType::BoundMember:
llvm_unreachable(
"Overloaded and dependent types shouldn't get to name mangling");
- break;
case BuiltinType::ObjCId: Out << "PAUobjc_object@@"; break;
case BuiltinType::ObjCClass: Out << "PAUobjc_class@@"; break;
case BuiltinType::ObjCSel: Out << "PAUobjc_selector@@"; break;
case BuiltinType::Char32:
case BuiltinType::NullPtr:
llvm_unreachable("Don't know how to mangle this type");
- break;
}
}
switch (getKind()) {
case Null:
llvm_unreachable("Should not have a NULL template argument");
- return false;
case Type:
return getAsType()->isDependentType();
switch (getKind()) {
case Null:
llvm_unreachable("Should not have a NULL template argument");
- return false;
case Type:
return getAsType()->isInstantiationDependentType();
switch (K) {
case InvalidTy:
llvm_unreachable("ArgTypeResult must be valid");
- return true;
case UnknownTy:
return true;
switch (K) {
case InvalidTy:
llvm_unreachable("No representative type for Invalid ArgTypeResult");
- // Fall-through.
case UnknownTy:
return QualType();
case SpecificTy:
}
llvm_unreachable("Unhandled ABIArgInfo::Kind");
- return RValue::get(0);
}
/* VarArg handling */
switch (BT->getKind()) {
case BuiltinType::Dependent:
llvm_unreachable("Unexpected builtin type Dependent");
- return llvm::DIType();
case BuiltinType::Overload:
llvm_unreachable("Unexpected builtin type Overload");
- return llvm::DIType();
case BuiltinType::BoundMember:
llvm_unreachable("Unexpected builtin type BoundMember");
- return llvm::DIType();
case BuiltinType::UnknownAny:
llvm_unreachable("Unexpected builtin type UnknownAny");
- return llvm::DIType();
case BuiltinType::NullPtr:
return DBuilder.
createNullPtrType(BT->getName(CGM.getContext().getLangOptions()));
return EmitFunctionDeclLValue(*this, E, FD);
llvm_unreachable("Unhandled member declaration!");
- return LValue();
}
LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value *BaseValue,
case CK_UncheckedDerivedToBase: {
llvm_unreachable("cannot perform hierarchy conversion in EmitAggExpr: "
"should have been unpacked before we got here");
- break;
}
case CK_GetObjCProperty: {
ComplexPairTy VisitStmt(Stmt *S) {
S->dump(CGF.getContext().getSourceManager());
llvm_unreachable("Stmt can't have complex result type!");
- return ComplexPairTy();
}
ComplexPairTy VisitExpr(Expr *S);
ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
return 0;
llvm_unreachable("Unable to handle InitListExpr");
- // Get rid of control reaches end of void function warning.
- // Not reached.
- return 0;
}
llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) {
switch (Result.Val.getKind()) {
case APValue::Uninitialized:
llvm_unreachable("Constant expressions should be initialized.");
- return 0;
case APValue::LValue: {
llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType);
llvm::Constant *Offset =
Value *VisitStmt(Stmt *S) {
S->dump(CGF.getContext().getSourceManager());
llvm_unreachable("Stmt can't have complex result type!");
- return 0;
}
Value *VisitExpr(Expr *S);
BinOp.Opcode = BO_Add;
BinOp.E = E;
return EmitOverflowCheckedBinOp(BinOp);
- break;
}
llvm_unreachable("Unknown SignedOverflowBehaviorTy");
- return 0;
}
llvm::Value *
case BO_Assign:
case BO_Comma:
llvm_unreachable("Not valid compound assignment operators");
- break;
}
llvm_unreachable("Unhandled compound assignment operator");
/// class of the given name.
virtual llvm::GlobalVariable *GetClassGlobal(const std::string &Name) {
llvm_unreachable("CGObjCMac::GetClassGlobal");
- return 0;
}
};
case Stmt::ObjCAtCatchStmtClass:
llvm_unreachable(
"@catch statements should be handled by EmitObjCAtTryStmt");
- break;
case Stmt::ObjCAtFinallyStmtClass:
llvm_unreachable(
"@finally statements should be handled by EmitObjCAtTryStmt");
- break;
case Stmt::ObjCAtThrowStmtClass:
EmitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(*S));
break;
if (!const_cast<CXXRecordDecl *>(DerivedRD)->
isDerivedFrom(const_cast<CXXRecordDecl *>(BaseRD), Paths)) {
llvm_unreachable("Class must be derived from the passed in base class!");
- return BaseOffset();
}
return ComputeBaseOffset(Context, DerivedRD, Paths.front());
}
llvm_unreachable("Should always find a vcall offset offset!");
- return CharUnits::Zero();
}
/// VCallAndVBaseOffsetBuilder - Class for building vcall and vbase offsets.
if (!const_cast<CXXRecordDecl *>(DerivedRD)->
isDerivedFrom(const_cast<CXXRecordDecl *>(BaseRD), Paths)) {
llvm_unreachable("Class must be derived from the passed in base class!");
- return BaseOffset();
}
// We have to go through all the paths, and see which one leads us to the
}
llvm_unreachable("Invalid action!");
- return 0;
}
ASTConsumer *CodeGenAction::CreateASTConsumer(CompilerInstance &CI,
if (&format == &llvm::APFloat::x87DoubleExtended)
return llvm::Type::getX86_FP80Ty(VMContext);
llvm_unreachable("Unknown float format!");
- return 0;
}
/// ConvertType - Convert the specified type to its LLVM form.
case X87:
case ComplexX87:
llvm_unreachable("Invalid classification for hi word.");
- break;
case NoClass: break;
}
llvm_unreachable("invalid class");
- return 0;
}
InputAction::InputAction(const Arg &_Input, types::ID _Type)
}
llvm_unreachable("invalid phase in ConstructPhaseAction");
- return 0;
}
bool Driver::IsUsingLTO(const ArgList &Args) const {
Arg *OptionGroup::accept(const ArgList &Args, unsigned &Index) const {
llvm_unreachable("accept() should never be called on an OptionGroup");
- return 0;
}
InputOption::InputOption(OptSpecifier ID)
Arg *InputOption::accept(const ArgList &Args, unsigned &Index) const {
llvm_unreachable("accept() should never be called on an InputOption");
- return 0;
}
UnknownOption::UnknownOption(OptSpecifier ID)
Arg *UnknownOption::accept(const ArgList &Args, unsigned &Index) const {
llvm_unreachable("accept() should never be called on an UnknownOption");
- return 0;
}
FlagOption::FlagOption(OptSpecifier ID, const char *Name,
}
llvm_unreachable("Invalid phase id.");
- return 0;
}
switch (getKind()) {
default: llvm_unreachable("Invalid Kind");
- return SourceRange();
case N_Decl:
return D->getSourceRange();
case N_Stmt:
case tok::kw_static_cast: return 4;
default:
llvm_unreachable("Unknown type for digraph error message.");
- return -1;
}
}
const char *CastName = 0; // For error messages
switch (Kind) {
- default: llvm_unreachable("Unknown C++ cast!"); abort();
+ default: llvm_unreachable("Unknown C++ cast!");
case tok::kw_const_cast: CastName = "const_cast"; break;
case tok::kw_dynamic_cast: CastName = "dynamic_cast"; break;
case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
llvm_unreachable("Annotation token should already be formed!");
default:
llvm_unreachable("Not a simple-type-specifier token!");
- abort();
// type-name
case tok::annot_typename: {
switch (NNS->getKind()) {
case NestedNameSpecifier::Identifier:
llvm_unreachable("Dependent nested-name-specifier has no DeclContext");
- break;
case NestedNameSpecifier::Namespace:
return NNS->getAsNamespace();
default:
llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
- return;
}
ResultBuilder Results(*this, CodeCompleter->getAllocator(), ContextKind);
} // switch (Name.getKind())
llvm_unreachable("Unknown name kind");
- return DeclarationNameInfo();
}
static QualType getCoreType(QualType Ty) {
}
llvm_unreachable("found no user-declared constructors");
- return;
}
break;
case CXXDestructor:
hasTrivial = &CXXRecordDecl::hasTrivialDestructor; break;
default:
- llvm_unreachable("unexpected special member"); return;
+ llvm_unreachable("unexpected special member");
}
// Check for nontrivial bases (and recurse).
switch (Attr.getKind()) {
default:
llvm_unreachable("invalid ownership attribute");
- return;
case AttributeList::AT_ns_returns_autoreleased:
D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(Attr.getRange(),
S.Context));
case CXXInvalid:
llvm_unreachable("Invalid special member.");
- break;
}
} else {
Diag(DefaultLoc, diag::err_default_special_members);
Ty = Context.LongLongTy;
else {
llvm_unreachable("I don't know size of pointer!");
- Ty = Context.IntTy;
}
return Owned(new (Context) GNUNullExpr(Ty, TokenLoc));
}
}
llvm_unreachable("Unreachable, bad result from BestViableFunction");
- return true;
}
case ImplicitConversionSequence::EllipsisConversion:
llvm_unreachable("Cannot perform an ellipsis conversion");
- return Owned(From);
case ImplicitConversionSequence::BadConversion:
return ExprError();
default:
llvm_unreachable("Improper first standard conversion");
- break;
}
// Perform the second implicit conversion
case ICK_Qualification:
case ICK_Num_Conversion_Kinds:
llvm_unreachable("Improper second standard conversion");
- break;
}
switch (SCS.Third) {
default:
llvm_unreachable("Improper third standard conversion");
- break;
}
return Owned(From);
case OR_Deleted:
llvm_unreachable("Conditional operator has only built-in overloads");
- break;
}
return true;
}
case OO_None:
case NUM_OVERLOADED_OPERATORS:
llvm_unreachable("Expected an overloaded operator");
- break;
case OO_New:
case OO_Delete:
case OO_Call:
llvm_unreachable(
"Special operators don't use AddBuiltinOperatorCandidates");
- break;
case OO_Comma:
case OO_Arrow:
// Can't be a DependentSizedArrayType or an IncompleteArrayType since
// UnqAT is not incomplete and Range is not type-dependent.
llvm_unreachable("Unexpected array type in for-range");
- return StmtError();
}
// end-expr is __range + __bound.
switch (Arg.getArgument().getKind()) {
case TemplateArgument::Null:
llvm_unreachable("Should never see a NULL template argument here");
- return true;
case TemplateArgument::Expression: {
TemplateArgument Result;
switch (Arg.getArgument().getKind()) {
case TemplateArgument::Null:
llvm_unreachable("Should never see a NULL template argument here");
- return true;
case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion:
case TSK_Undeclared:
case TSK_ImplicitInstantiation:
llvm_unreachable("Don't check implicit instantiations here");
- return false;
case TSK_ExplicitSpecialization:
switch (PrevTSK) {
}
llvm_unreachable("Missing specialization/instantiation case?");
-
- return false;
}
/// \brief Perform semantic analysis for the given dependent function
switch (Param.getKind()) {
case TemplateArgument::Null:
llvm_unreachable("Null template argument in parameter list");
- break;
case TemplateArgument::Type:
if (Arg.getKind() == TemplateArgument::Type)
switch (X.getKind()) {
case TemplateArgument::Null:
llvm_unreachable("Comparing NULL template argument");
- break;
case TemplateArgument::Type:
return Context.getCanonicalType(X.getAsType()) ==
Decl *
TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
llvm_unreachable("Translation units cannot be instantiated");
- return D;
}
Decl *
Decl *
TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
llvm_unreachable("Namespaces cannot be instantiated");
- return D;
}
Decl *
Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
llvm_unreachable("EnumConstantDecls can only occur within EnumDecls.");
- return 0;
}
Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static)
break;
switch (cast<TagDecl>(SemaRef.CurContext)->getTagKind()) {
- case TTK_Enum: llvm_unreachable("unhandled tag kind"); break;
+ case TTK_Enum: llvm_unreachable("unhandled tag kind");
case TTK_Struct: Error = 1; /* Struct member */ break;
case TTK_Union: Error = 2; /* Union member */ break;
case TTK_Class: Error = 3; /* Class member */ break;
default:
llvm_unreachable("Invalid C++ named cast");
- break;
}
return ExprError();
}
llvm_unreachable("Unknown name kind.");
- return DeclarationNameInfo();
}
template<typename Derived>
ExprResult
TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
llvm_unreachable("Cannot transform asType expressions yet");
- return SemaRef.Owned(E);
}
//===----------------------------------------------------------------------===//
}
llvm_unreachable("Unhandled template name kind!");
- return TemplateName();
}
TemplateArgument
}
llvm_unreachable("Unhandled template argument kind!");
- return TemplateArgument();
}
TemplateParameterList *
FD->IdentifierNamespace = Record[Idx++];
switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
default: llvm_unreachable("Unhandled TemplatedKind!");
- break;
case FunctionDecl::TK_NonTemplate:
break;
case FunctionDecl::TK_FunctionTemplate:
case DECL_CONTEXT_LEXICAL:
case DECL_CONTEXT_VISIBLE:
llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
- break;
case DECL_TYPEDEF:
D = TypedefDecl::Create(Context, 0, SourceLocation(), SourceLocation(),
0, 0);
Record.push_back(D->getTemplatedKind());
switch (D->getTemplatedKind()) {
default: llvm_unreachable("Unhandled TemplatedKind!");
- break;
case FunctionDecl::TK_NonTemplate:
break;
case FunctionDecl::TK_FunctionTemplate:
if (errorNode->isSink()) {
llvm_unreachable(
"BugType::isSuppressSink() should not be 'true' for sink end nodes");
- return 0;
}
// No successors? By definition this nodes isn't post-dominated by a sink.
if (errorNode->succ_empty()) {
switch (Term->getStmtClass()) {
default:
llvm_unreachable("Analysis for this terminator not implemented.");
- break;
case Stmt::BinaryOperatorClass: // '&&' and '||'
HandleBranch(cast<BinaryOperator>(Term)->getLHS(), Term, B, Pred);
}
llvm_unreachable("No block with label.");
- return;
}
if (isa<loc::ConcreteInt>(V) || isa<UndefinedVal>(V)) {
switch (U->getOpcode()) {
default:
llvm_unreachable("Invalid Opcode.");
- break;
case UO_Not:
// FIXME: Do we need to handle promotions?
if (isa<CodeTextRegion>(MR)) {
llvm_unreachable("Why load from a code text region?");
- return UnknownVal();
}
// FIXME: Perhaps this method should just take a 'const MemRegion*' argument
}
default:
llvm_unreachable("Pretty-printing not implemented for this Loc.");
- break;
}
}
case BO_LAnd:
case BO_LOr:
llvm_unreachable("Logical operators handled by branching logic.");
- return UnknownVal();
case BO_Assign:
case BO_MulAssign:
case BO_DivAssign:
case BO_OrAssign:
case BO_Comma:
llvm_unreachable("'=' and ',' operators handled by ExprEngine.");
- return UnknownVal();
case BO_PtrMemD:
case BO_PtrMemI:
llvm_unreachable("Pointer arithmetic not handled here.");
- return UnknownVal();
case BO_LT:
case BO_GT:
case BO_LE:
switch (op) {
default:
llvm_unreachable("Unimplemented operation for two identical values");
- return UnknownVal();
case BO_Sub:
return makeZeroVal(resultTy);
case BO_EQ:
switch (lhs.getSubKind()) {
default:
llvm_unreachable("Ordering not implemented for this Loc.");
- return UnknownVal();
case loc::GotoLabelKind:
// The only thing we know about labels is that they're non-null.
case MemRegion::NonStaticGlobalSpaceRegionKind:
case MemRegion::StaticGlobalSpaceRegionKind: {
llvm_unreachable("Invalid region cast");
- break;
}
case MemRegion::FunctionTextRegionKind:
}
llvm_unreachable("unreachable");
- return 0;
}
default:
llvm_unreachable("Unhandled Base.");
- return Base;
}
// NOTE: We must have this check first because ObjCIvarDecl is a subclass
switch (Op) {
default:
llvm_unreachable("operator printing not implemented");
- break;
case BO_Mul: os << '*' ; break;
case BO_Div: os << '/' ; break;
case BO_Rem: os << '%' ; break;
/* Print warning/error/etc. */
switch (Severity) {
- case CXDiagnostic_Ignored: llvm_unreachable("impossible"); break;
+ case CXDiagnostic_Ignored: llvm_unreachable("impossible");
case CXDiagnostic_Note: Out << "note: "; break;
case CXDiagnostic_Warning: Out << "warning: "; break;
case CXDiagnostic_Error: Out << "error: "; break;
projects / clang / commitdiff