Adding a new [[clang::impossible_enum]] attribute to clang

[beanz]

Summary

This attribute provides a way to instruct the compiler that a given enum value is never valid. This specification can allow large segments of code to be dead stripped.

One hypothetical use of this is my RFC on stripping intrinsics for un-used targets in LLVM (http://lists.cs.uiuc.edu/pipermail/llvmdev/2014-December/079818.html).

In this case the attribute would allow us to remove the code and constant data for unusable attributes without needing to litter around #ifdefs.

Disclaimer: This idea came from Alex Rosenberg... Beware.

[rnk]

This is an interesting idea, but I kind of want to hold off on it. I think TableGen is just making the wrong tradeoff between code size and performance in Intrinsics.gen here.

include/clang/Basic/Attr.td

 }
 
 def OMPThreadPrivateDecl : InheritableAttr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];
   let SemaHandler = 0;
   let Documentation = [Undocumented];
 }
+
+def ImpossibleEnum : Attr {
+  let Spellings = [CXX11<"clang","impossible_enum">];
+  let Subjects = SubjectList<[EnumConstant], ErrorDiag>;
+  let Documentation = [ImpossibleEnumDocs];
+}
+

include/clang/Basic/AttrDocs.td

 The private address space specifies that an object is allocated in the private
 (work item) memory. Other work items cannot access the same memory area and its
 content is destroyed after work item execution ends. Local variables can be
 declared in the private address space. Function arguments are always in the
 private address space. Kernel function arguments of a pointer or an array type
 cannot point to the private address space.
   }];
 }
+
+def ImpossibleEnumDocs : Documentation {
+  let Category = DocCatVariable;
+  let Heading = "[[clang::impossible_enum]]";
+  let Content = [{
+The impossible_enum attribute specifies to the compiler that enum values with
+this attribute are never valid. This allows the compiler to treat branches based
+on this enum value as dead code. This attribute only impacts the behavior of
+switch statements and conditional expressions. In switch statements any case
+labels which are based on an impossible_enum are not emitted to the IR. In
+conditional expressions equality against impossible_enum values is always false,
+all other boolean operators are true.
+  }];
+}

include/clang/Sema/AttributeList.h

enum AttributeDeclKind {
   ExpectedVariableOrFunction,
   ExpectedFunctionOrMethod,
   ExpectedParameter,
   ExpectedFunctionMethodOrBlock,
   ExpectedFunctionMethodOrClass,
   ExpectedFunctionMethodOrParameter,
   ExpectedClass,
   ExpectedEnum,
+  ExpectedEnumConstant,
   ExpectedVariable,
   ExpectedMethod,
   ExpectedVariableFunctionOrLabel,
   ExpectedFieldOrGlobalVar,
   ExpectedStruct,
   ExpectedVariableOrTypedef,
   ExpectedTLSVar,
   ExpectedVariableOrField,

lib/CodeGen/CGExprScalar.cpp

case BuiltinType::Float:
     return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p :
                             llvm::Intrinsic::ppc_altivec_vcmpgtfp_p;
   }
 }
 
 Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc,
                                       unsigned SICmpOpc, unsigned FCmpOpc) {
   TestAndClearIgnoreResultAssign();
-  Value *Result;
+  Value *Result = nullptr;
   QualType LHSTy = E->getLHS()->getType();
   QualType RHSTy = E->getRHS()->getType();
+
+  auto *LHSDeclRef = dyn_cast<DeclRefExpr>(E->getLHS()->IgnoreCasts());
+  auto *RHSDeclRef = dyn_cast<DeclRefExpr>(E->getRHS()->IgnoreCasts());
+  bool impossibleEnum =
+      (LHSDeclRef && LHSDeclRef->getDecl()->hasAttr<ImpossibleEnumAttr>()) ||
+      (RHSDeclRef && RHSDeclRef->getDecl()->hasAttr<ImpossibleEnumAttr>());
+  if (impossibleEnum) {
+    if (E->getOpcode() == BO_EQ)
+      Result = llvm::ConstantInt::getFalse(ConvertType(E->getType()));
+    else
+      Result = llvm::ConstantInt::getTrue(ConvertType(E->getType()));
+    return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType());
+  }
+
   if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) {
     assert(E->getOpcode() == BO_EQ ||
            E->getOpcode() == BO_NE);
     Value *LHS = CGF.EmitScalarExpr(E->getLHS());
     Value *RHS = CGF.EmitScalarExpr(E->getRHS());
     Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison(
                    CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE);
   } else if (!LHSTy->isAnyComplexType() && !RHSTy->isAnyComplexType()) {

lib/CodeGen/CGStmt.cpp

 //===--- CGStmt.cpp - Emit LLVM Code from Statements ----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This contains code to emit Stmt nodes as LLVM code.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeGenFunction.h"
 #include "CGDebugInfo.h"
+#include "CGBuilder.h"
 #include "CodeGenModule.h"
 #include "TargetInfo.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Basic/PrettyStackTrace.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/LoopHint.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "llvm/ADT/StringExtras.h"
if (isObviouslyBranchWithoutCleanups(Block)) {
       if (Builder.GetInsertBlock()) {
         Builder.CreateBr(Block.getBlock());
         Builder.ClearInsertionPoint();
       }
       return;
     }
   }
 
-  llvm::BasicBlock *CaseDest = createBasicBlock("sw.bb");
-  EmitBlockWithFallThrough(CaseDest, CaseCnt);
+  const DeclRefExpr *EnumDeclExpr =
+      dyn_cast<DeclRefExpr>(S.getLHS()->IgnoreCasts());
+  bool isCaseImpossible =
+      EnumDeclExpr && EnumDeclExpr->getDecl()->hasAttr<ImpossibleEnumAttr>();
+
+  llvm::BasicBlock *CaseDest = nullptr;
   if (SwitchWeights)
     SwitchWeights->push_back(CaseCnt.getCount());
+  if (!isCaseImpossible) {
+    if (!CaseDest) {
+      CaseDest = createBasicBlock("sw.bb");
+      EmitBlockWithFallThrough(CaseDest, CaseCnt);
+    }
     SwitchInsn->addCase(CaseVal, CaseDest);
+  }
 
   // Recursively emitting the statement is acceptable, but is not wonderful for
   // code where we have many case statements nested together, i.e.:
   //  case 1:
   //    case 2:
   //      case 3: etc.
   // Handling this recursively will create a new block for each case statement
   // that falls through to the next case which is IR intensive.  It also causes
   // deep recursion which can run into stack depth limitations.  Handle
   // sequential non-range case statements specially.
   const CaseStmt *CurCase = &S;
   const CaseStmt *NextCase = dyn_cast<CaseStmt>(S.getSubStmt());
 
   // Otherwise, iteratively add consecutive cases to this switch stmt.
   while (NextCase && NextCase->getRHS() == nullptr) {
     CurCase = NextCase;
     llvm::ConstantInt *CaseVal =
       Builder.getInt(CurCase->getLHS()->EvaluateKnownConstInt(getContext()));
 
+    EnumDeclExpr = dyn_cast<DeclRefExpr>(CurCase->getLHS()->IgnoreCasts());
+    isCaseImpossible =
+        EnumDeclExpr && EnumDeclExpr->getDecl()->hasAttr<ImpossibleEnumAttr>();
+
     CaseCnt = getPGORegionCounter(NextCase);
     if (SwitchWeights)
       SwitchWeights->push_back(CaseCnt.getCount());
     if (CGM.getCodeGenOpts().ProfileInstrGenerate) {
       CaseDest = createBasicBlock("sw.bb");
       EmitBlockWithFallThrough(CaseDest, CaseCnt);
     }
 
+    if (!isCaseImpossible) {
+      if (!CaseDest) {
+        CaseDest = createBasicBlock("sw.bb");
+        EmitBlockWithFallThrough(CaseDest, CaseCnt);
+      }
       SwitchInsn->addCase(CaseVal, CaseDest);
+    }
     NextCase = dyn_cast<CaseStmt>(CurCase->getSubStmt());
   }
 
   // Normal default recursion for non-cases.
   EmitStmt(CurCase->getSubStmt());
 }
 
 void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) {

lib/Sema/SemaDeclAttr.cpp

static void handleAlwaysInlineAttr(Sema &S, Decl *D,
   if (checkAttrMutualExclusion<OptimizeNoneAttr>(S, D, Attr))
     return;
 
   D->addAttr(::new (S.Context)
              AlwaysInlineAttr(Attr.getRange(), S.Context,
                               Attr.getAttributeSpellingListIndex()));
 }
 
+static void handleImpossibleEnumAttr(Sema &S, Decl *D,
+                                      const AttributeList &Attr) {
+  if (checkAttrMutualExclusion<OptimizeNoneAttr>(S, D, Attr))
+    return;
+
+  D->addAttr(::new (S.Context)
+            ImpossibleEnumAttr(Attr.getRange(), S.Context,
+                                Attr.getAttributeSpellingListIndex()));
+}
+
 static void handleMinSizeAttr(Sema &S, Decl *D,
                               const AttributeList &Attr) {
   if (checkAttrMutualExclusion<OptimizeNoneAttr>(S, D, Attr))
     return;
 
   D->addAttr(::new (S.Context)
              MinSizeAttr(Attr.getRange(), S.Context,
                          Attr.getAttributeSpellingListIndex()));
case AttributeList::AT_Aligned:
     handleAlignedAttr(S, D, Attr);
     break;
   case AttributeList::AT_AlignValue:
     handleAlignValueAttr(S, D, Attr);
     break;
   case AttributeList::AT_AlwaysInline:
     handleAlwaysInlineAttr(S, D, Attr);
     break;
+  case AttributeList::AT_ImpossibleEnum:
+    handleImpossibleEnumAttr(S, D, Attr);
+    break;
   case AttributeList::AT_AnalyzerNoReturn:
     handleAnalyzerNoReturnAttr(S, D, Attr);
     break;
   case AttributeList::AT_TLSModel:
     handleTLSModelAttr(S, D, Attr);
     break;
   case AttributeList::AT_Annotate:
     handleAnnotateAttr(S, D, Attr);

test/CodeGenCXX/impossible_enum.cpp

+// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - | FileCheck %s
+
+void printf(const char*, ...);
+
+enum ImpossibleEnum {
+  value1,
+  value2,
+  value3 [[clang::impossible_enum]]
+};
+
+// CHECK: switch
+// CHECK: label
+// CHECK: label
+// CHECK: ]
+// CHECK: call
+// CHECK: call
+// CHECK: ret void
+void foo(int i) {
+  switch(i) {
+    case value1:
+      printf("value1");
+      break;
+    case value3:
+      printf("value3");
+    case value2:
+      printf("value2");
+      break;
+    default:
+      break;
+  }
+}
+
+// CHECK: switch
+// CHECK: label
+// CHECK: label
+// CHECK: ]
+// CHECK: call
+// CHECK: call
+// CHECK: call
+// CHECK: ret void
+void bar(int i) {
+  switch(i) {
+    case value1:
+      printf("value1");
+      break;
+    case value2:
+      printf("value2");
+    case value3:
+      printf("value3");
+      break;
+    default:
+      break;
+  }
+}
+
+// CHECK: switch
+// CHECK: label
+// CHECK: label
+// CHECK: ]
+// CHECK: call
+// CHECK: call
+// CHECK: ret void
+void baz(int i) {
+  switch(i) {
+    case value1:
+      printf("value1");
+      break;
+    case value2:
+    case value3:
+      printf("value23");
+      break;
+    default:
+      break;
+  }
+}
+
+// CHECK: br i1 true
+// CHECK: br i1 false
+int main(int argc, char**) {
+  foo(argc);
+  bar(argc);
+  baz(argc);
+  if(argc != value3)
+    printf("true");
+  if(argc == value3)
+    printf("false");
+  return 0;
+}

utils/TableGen/ClangAttrEmitter.cpp

enum {
     ObjCIVar = 1U << 7,
     ObjCProp = 1U << 8,
     ObjCInterface = 1U << 9,
     Block = 1U << 10,
     Namespace = 1U << 11,
     Field = 1U << 12,
     CXXMethod = 1U << 13,
     ObjCProtocol = 1U << 14,
-    Enum = 1U << 15
+    Enum = 1U << 15,
+    EnumConstant = 1U << 16
   };
   uint32_t SubMask = 0;
 
   std::vector<Record *> Subjects = S.getValueAsListOfDefs("Subjects");
   for (const auto *Subject : Subjects) {
     const Record &R = *Subject;
     std::string Name;
 
uint32_t V = StringSwitch<uint32_t>(Name)
                    .Case("ObjCInterface", ObjCInterface)
                    .Case("ObjCProtocol", ObjCProtocol)
                    .Case("Block", Block)
                    .Case("CXXRecord", Class)
                    .Case("Namespace", Namespace)
                    .Case("Field", Field)
                    .Case("CXXMethod", CXXMethod)
                    .Case("Enum", Enum)
+                   .Case("EnumConstant", EnumConstant)
                    .Default(0);
     if (!V) {
       // Something wasn't in our mapping, so be helpful and let the developer
       // know about it.
       PrintFatalError(R.getLoc(), "Unknown subject type: " + R.getName());
       return "";
     }
 
     SubMask |= V;
   }
 
   switch (SubMask) {
     // For the simple cases where there's only a single entry in the mask, we
     // don't have to resort to bit fiddling.
     case Func:  return "ExpectedFunction";
     case Var:   return "ExpectedVariable";
     case Param: return "ExpectedParameter";
     case Class: return "ExpectedClass";
     case Enum:  return "ExpectedEnum";
+    case EnumConstant:  return "ExpectedEnumConstant";
     case CXXMethod:
       // FIXME: Currently, this maps to ExpectedMethod based on existing code,
       // but should map to something a bit more accurate at some point.
     case ObjCMethod:  return "ExpectedMethod";
     case Type:  return "ExpectedType";
     case ObjCInterface: return "ExpectedObjectiveCInterface";
     case ObjCProtocol: return "ExpectedObjectiveCProtocol";