IR: Move AtomicRMW string names into class

[arsenm]

Summary

This will be used to improve error messages in a future commit

[jfb]

include/llvm/IR/Instructions.h

768

This is probably better to have in a .cpp file.

[arsenm]

r343647

include/llvm/IR/Instructions.h

public:
   void *operator new(size_t s) {
     return User::operator new(s, 2);
   }
 
   BinOp getOperation() const {
     return static_cast<BinOp>(getSubclassDataFromInstruction() >> 5);
   }
 
+  static StringRef getOperationName(BinOp Op) {
+    switch (Op) {
+    case AtomicRMWInst::Xchg:
+      return "xchg";
+    case AtomicRMWInst::Add:
+      return "add";
+    case AtomicRMWInst::Sub:
+      return "sub";
+    case AtomicRMWInst::And:
+      return "and";
+    case AtomicRMWInst::Nand:
+      return "nand";
+    case AtomicRMWInst::Or:
+      return "or";
+    case AtomicRMWInst::Xor:
+      return "xor";
+    case AtomicRMWInst::Max:
+      return "max";
+    case AtomicRMWInst::Min:
+      return "min";
+    case AtomicRMWInst::UMax:
+      return "umax";
+    case AtomicRMWInst::UMin:
+      return "umin";
+    case AtomicRMWInst::BAD_BINOP:
+      return "<invalid operation>";
+    }
+
+    llvm_unreachable("invalid atomicrmw operation");
+  }
+
   void setOperation(BinOp Operation) {
     unsigned short SubclassData = getSubclassDataFromInstruction();
     setInstructionSubclassData((SubclassData & 31) |
                                (Operation << 5));
   }
 
   /// Return true if this is a RMW on a volatile memory location.
   ///

lib/IR/AsmWriter.cpp

static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
                                    SlotTracker *Machine,
                                    const Module *Context);
 
 static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
                                    TypePrinting *TypePrinter,
                                    SlotTracker *Machine, const Module *Context,
                                    bool FromValue = false);
 
-static void writeAtomicRMWOperation(raw_ostream &Out,
-                                    AtomicRMWInst::BinOp Op) {
-  switch (Op) {
-  default: Out << " <unknown operation " << Op << ">"; break;
-  case AtomicRMWInst::Xchg: Out << " xchg"; break;
-  case AtomicRMWInst::Add:  Out << " add"; break;
-  case AtomicRMWInst::Sub:  Out << " sub"; break;
-  case AtomicRMWInst::And:  Out << " and"; break;
-  case AtomicRMWInst::Nand: Out << " nand"; break;
-  case AtomicRMWInst::Or:   Out << " or"; break;
-  case AtomicRMWInst::Xor:  Out << " xor"; break;
-  case AtomicRMWInst::Max:  Out << " max"; break;
-  case AtomicRMWInst::Min:  Out << " min"; break;
-  case AtomicRMWInst::UMax: Out << " umax"; break;
-  case AtomicRMWInst::UMin: Out << " umin"; break;
-  }
-}
-
 static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
   if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) {
     // 'Fast' is an abbreviation for all fast-math-flags.
     if (FPO->isFast())
       Out << " fast";
     else {
       if (FPO->hasAllowReassoc())
         Out << " reassoc";
void AssemblyWriter::printInstruction(const Instruction &I) {
   WriteOptimizationInfo(Out, &I);
 
   // Print out the compare instruction predicates
   if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
     Out << ' ' << CmpInst::getPredicateName(CI->getPredicate());
 
   // Print out the atomicrmw operation
   if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
-    writeAtomicRMWOperation(Out, RMWI->getOperation());
+    Out << ' ' << AtomicRMWInst::getOperationName(RMWI->getOperation());
 
   // Print out the type of the operands...
   const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;
 
   // Special case conditional branches to swizzle the condition out to the front
   if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
     const BranchInst &BI(cast<BranchInst>(I));
     Out << ' ';