[llvm] Replacing asserts with static_asserts where appropriate

[eszasip]

Summary

This patch consists of the suggestions of clang-tidy/misc-static-assert check.

[alexfh]

Looks good!

Please have someone commit this for you.

[xazax.hun]

This patch was committed in: r232366.

It looks like this patch fails to compile on windows using msvc: http://lab.llvm.org:8011/builders/lldb-x86-windows-msvc/builds/3291

Unfortunately I do not have access to a msvc compiler. Should I revert the whole patch in this case?

[alexfh]

Given that each change is independent, I'd start from reverting the one
where the error appears. It seems that MSVC doesn't understand constexpr on
llvm::array_lengthof.

[xazax.hun]

I did revert that part of the patch in the meantime and it seems to solve the issue.

[chfast]

In D8343#141230, @alexfh wrote:

Given that each change is independent, I'd start from reverting the one
where the error appears. It seems that MSVC doesn't understand constexpr on
llvm::array_lengthof.

constexpr is one of the biggest missing feature of MSVC. The partial support is expected in Visual Studio 2015.

lib/CodeGen/MachineVerifier.cpp

if (!MI->getOperand(0).isSymbol())
     report("Asm string must be an external symbol", MI);
   if (!MI->getOperand(1).isImm())
     report("Asm flags must be an immediate", MI);
   // Allowed flags are Extra_HasSideEffects = 1, Extra_IsAlignStack = 2,
   // Extra_AsmDialect = 4, Extra_MayLoad = 8, and Extra_MayStore = 16.
   if (!isUInt<5>(MI->getOperand(1).getImm()))
     report("Unknown asm flags", &MI->getOperand(1), 1);
 
-  assert(InlineAsm::MIOp_FirstOperand == 2 && "Asm format changed");
+  static_assert(InlineAsm::MIOp_FirstOperand == 2, "Asm format changed");
 
   unsigned OpNo = InlineAsm::MIOp_FirstOperand;
   unsigned NumOps;
   for (unsigned e = MI->getNumOperands(); OpNo < e; OpNo += NumOps) {
     const MachineOperand &MO = MI->getOperand(OpNo);
     // There may be implicit ops after the fixed operands.
     if (!MO.isImm())
       break;

lib/CodeGen/SlotIndexes.cpp

void SlotIndexes::renumberIndexes() {
   }
 }
 
 // Renumber indexes locally after curItr was inserted, but failed to get a new
 // index.
 void SlotIndexes::renumberIndexes(IndexList::iterator curItr) {
   // Number indexes with half the default spacing so we can catch up quickly.
   const unsigned Space = SlotIndex::InstrDist/2;
-  assert((Space & 3) == 0 && "InstrDist must be a multiple of 2*NUM");
+  static_assert((Space & 3) == 0, "InstrDist must be a multiple of 2*NUM");
 
   IndexList::iterator startItr = std::prev(curItr);
   unsigned index = startItr->getIndex();
   do {
     curItr->setIndex(index += Space);
     ++curItr;
     // If the next index is bigger, we have caught up.
   } while (curItr != indexList.end() && curItr->getIndex() <= index);

lib/MC/MCDwarf.cpp

static const char StandardOpcodeLengths[] = {
       0, // length of DW_LNS_negate_stmt
       0, // length of DW_LNS_set_basic_block
       0, // length of DW_LNS_const_add_pc
       1, // length of DW_LNS_fixed_advance_pc
       0, // length of DW_LNS_set_prologue_end
       0, // length of DW_LNS_set_epilogue_begin
       1  // DW_LNS_set_isa
   };
-  assert(array_lengthof(StandardOpcodeLengths) == (DWARF2_LINE_OPCODE_BASE - 1));
+  static_assert(array_lengthof(StandardOpcodeLengths) ==
+                    (DWARF2_LINE_OPCODE_BASE - 1),
+                "");
   return Emit(MCOS, StandardOpcodeLengths);
 }
 
 static const MCExpr *forceExpAbs(MCStreamer &OS, const MCExpr* Expr) {
   MCContext &Context = OS.getContext();
   assert(!isa<MCSymbolRefExpr>(Expr));
   if (Context.getAsmInfo()->hasAggressiveSymbolFolding())
     return Expr;

lib/Support/FoldingSet.cpp

void FoldingSetNodeID::AddString(StringRef String) {
   // If the string is aligned do a bulk transfer.
   if (!((intptr_t)Base & 3)) {
     Bits.append(Base, Base + Units);
     Pos = (Units + 1) * 4;
   } else {
     // Otherwise do it the hard way.
     // To be compatible with above bulk transfer, we need to take endianness
     // into account.
+    static_assert(sys::IsBigEndianHost || sys::IsLittleEndianHost,
+                  "Unexpected host endianness");
     if (sys::IsBigEndianHost) {
       for (Pos += 4; Pos <= Size; Pos += 4) {
         unsigned V = ((unsigned char)String[Pos - 4] << 24) |
                      ((unsigned char)String[Pos - 3] << 16) |
                      ((unsigned char)String[Pos - 2] << 8) |
                       (unsigned char)String[Pos - 1];
         Bits.push_back(V);
       }
-    } else {
-      assert(sys::IsLittleEndianHost && "Unexpected host endianness");
+    } else {  // Little-endian host
       for (Pos += 4; Pos <= Size; Pos += 4) {
         unsigned V = ((unsigned char)String[Pos - 1] << 24) |
                      ((unsigned char)String[Pos - 2] << 16) |
                      ((unsigned char)String[Pos - 3] << 8) |
                       (unsigned char)String[Pos - 4];
         Bits.push_back(V);
       }
     }

lib/Target/X86/X86FloatingPoint.cpp

 /// runOnMachineFunction - Loop over all of the basic blocks, transforming FP
 /// register references into FP stack references.
 ///
 bool FPS::runOnMachineFunction(MachineFunction &MF) {
   // We only need to run this pass if there are any FP registers used in this
   // function.  If it is all integer, there is nothing for us to do!
   bool FPIsUsed = false;
 
-  assert(X86::FP6 == X86::FP0+6 && "Register enums aren't sorted right!");
+  static_assert(X86::FP6 == X86::FP0+6, "Register enums aren't sorted right!");
   for (unsigned i = 0; i <= 6; ++i)
     if (MF.getRegInfo().isPhysRegUsed(X86::FP0+i)) {
       FPIsUsed = true;
       break;
     }
 
   // Early exit.
   if (!FPIsUsed) return false;

lib/Target/X86/X86ISelLowering.cpp

X86TargetLowering::EmitVAARG64WithCustomInserter(MachineInstr *MI,
   // 0  ) Output        : destination address (reg)
   // 1-5) Input         : va_list address (addr, i64mem)
   // 6  ) ArgSize       : Size (in bytes) of vararg type
   // 7  ) ArgMode       : 0=overflow only, 1=use gp_offset, 2=use fp_offset
   // 8  ) Align         : Alignment of type
   // 9  ) EFLAGS (implicit-def)
 
   assert(MI->getNumOperands() == 10 && "VAARG_64 should have 10 operands!");
-  assert(X86::AddrNumOperands == 5 && "VAARG_64 assumes 5 address operands");
+  static_assert(X86::AddrNumOperands == 5,
+                "VAARG_64 assumes 5 address operands");
 
   unsigned DestReg = MI->getOperand(0).getReg();
   MachineOperand &Base = MI->getOperand(1);
   MachineOperand &Scale = MI->getOperand(2);
   MachineOperand &Index = MI->getOperand(3);
   MachineOperand &Disp = MI->getOperand(4);
   MachineOperand &Segment = MI->getOperand(5);
   unsigned ArgSize = MI->getOperand(6).getImm();

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 // Set Size bytes starting from ShadowBase to kAsanStackAfterReturnMagic.
 // We can not use MemSet intrinsic because it may end up calling the actual
 // memset. Size is a multiple of 8.
 // Currently this generates 8-byte stores on x86_64; it may be better to
 // generate wider stores.
 void FunctionStackPoisoner::SetShadowToStackAfterReturnInlined(
     IRBuilder<> &IRB, Value *ShadowBase, int Size) {
   assert(!(Size % 8));
-  assert(kAsanStackAfterReturnMagic == 0xf5);
+
+  #ifndef NDEBUG
+  static_assert(kAsanStackAfterReturnMagic == 0xf5, "");
+  #endif
+
   for (int i = 0; i < Size; i += 8) {
     Value *p = IRB.CreateAdd(ShadowBase, ConstantInt::get(IntptrTy, i));
     IRB.CreateStore(ConstantInt::get(IRB.getInt64Ty(), 0xf5f5f5f5f5f5f5f5ULL),
                     IRB.CreateIntToPtr(p, IRB.getInt64Ty()->getPointerTo()));
   }
 }
 
 static DebugLoc getFunctionEntryDebugLocation(Function &F) {

unittests/ADT/SCCIteratorTest.cpp

TEST(SCCIteratorTest, AllSmallGraphs) {
   // Test SCC computation against every graph with NUM_NODES nodes or less.
   // Since SCC considers every node to have an implicit self-edge, we only
   // create graphs for which every node has a self-edge.
 #define NUM_NODES 4
 #define NUM_GRAPHS (NUM_NODES * (NUM_NODES - 1))
   typedef Graph<NUM_NODES> GT;
 
   /// Enumerate all graphs using NUM_GRAPHS bits.
-  assert(NUM_GRAPHS < sizeof(unsigned) * CHAR_BIT && "Too many graphs!");
+  static_assert(NUM_GRAPHS < sizeof(unsigned) * CHAR_BIT, "Too many graphs!");
   for (unsigned GraphDescriptor = 0; GraphDescriptor < (1U << NUM_GRAPHS);
        ++GraphDescriptor) {
     GT G;
 
     // Add edges as specified by the descriptor.
     unsigned DescriptorCopy = GraphDescriptor;
     for (unsigned i = 0; i != NUM_NODES; ++i)
       for (unsigned j = 0; j != NUM_NODES; ++j) {