[PATCH 6/8] Implement noclobber function attribute

include/llvm/IR/Attributes.h

 class AttrBuilder {
   std::bitset<Attribute::EndAttrKinds> Attrs;
   std::map<std::string, std::string> TargetDepAttrs;
+  SmallVector<unsigned, 4> NoClobberAttrs;
   uint64_t Alignment;
   uint64_t StackAlignment;
   uint64_t DerefBytes;

include/llvm/Target/TargetRegisterInfo.h

 #include "llvm/MC/MCRegisterInfo.h"
 #include <cassert>
 #include <functional>
+#include <map>
 
 namespace llvm {
 

 
   regclass_iterator RegClassBegin, RegClassEnd;   // List of regclasses
   unsigned CoveringLanes;
+  typedef MCPhysReg *MCPhysRegList;
+  static std::map<std::string, MCPhysRegList> ExplicitCCNoclobbers;
 
 protected:
   TargetRegisterInfo(const TargetRegisterInfoDesc *ID,

     return nullptr;
   }
 
+  /// getExplicitCCNoclobberList - Return a null-terminated list of all of the
+  /// callee saved registers as specified for by the noclobber attribute for MF.
+  static const MCPhysReg *getExplicitCCNoclobberList(const MachineFunction *MF);
+
   /// getReservedRegs - Returns a bitset indexed by physical register number
   /// indicating if a register is a special register that has particular uses
   /// and should be considered unavailable at all times, e.g. SP, RA. This is

lib/AsmParser/LLLexer.cpp

   KEYWORD(cold);
   KEYWORD(dereferenceable);
   KEYWORD(hwreg);
+  KEYWORD(noclobber);
   KEYWORD(inlinehint);
   KEYWORD(inreg);
   KEYWORD(jumptable);

lib/AsmParser/LLParser.h

     bool ParseOptionalAlignment(unsigned &Alignment);
     bool ParseOptionalDereferenceableBytes(uint64_t &Bytes);
     bool ParseOptionalHWReg(uint64_t &Reg);
+    bool ParseNoclobberAttrib(std::string &Regs);
     bool ParseScopeAndOrdering(bool isAtomic, SynchronizationScope &Scope,
                                AtomicOrdering &Ordering);
     bool ParseOrdering(AtomicOrdering &Ordering);

lib/AsmParser/LLParser.cpp

     case lltok::kw_sanitize_thread:   B.addAttribute(Attribute::SanitizeThread); break;
     case lltok::kw_sanitize_memory:   B.addAttribute(Attribute::SanitizeMemory); break;
     case lltok::kw_uwtable:           B.addAttribute(Attribute::UWTable); break;
-
+    case lltok::kw_noclobber: {
+      std::string tmp;
+      if (ParseNoclobberAttrib(tmp))
+        HaveError |=  Error(Lex.getLoc(), "malformed noclobber attribute");
+      B.addAttribute("noclobber", tmp);
+      break;
+    }
     // Error handling.
     case lltok::kw_inreg:
     case lltok::kw_signext:

   return false;
 }
 
+bool LLParser::ParseNoclobberAttrib(std::string &Regs)
+{
+  Lex.Lex();
+  if (ParseToken(lltok::lparen, "expected '(' in noclobber attribute"))
+    return true;
+
+  while (true) {
+    if (Lex.getKind() == lltok::rparen) {
+      return false; // We have found the end of the list
+    }
+    unsigned Id;
+    if (ParseUInt32(Id)) {
+      return true;
+    }
+    Regs.append(std::to_string(Id) + " ");
+    if (Lex.getKind() == lltok::rparen) {
+      continue;
+    } else if (Lex.getKind() == lltok::comma) {
+      Lex.Lex();
+    } else {
+      return TokError("expected ')' or ',' in noclobber attribute");
+    }
+  }
+}
+
 /// ParseOptionalCommaAlign
 ///   ::=
 ///   ::= ',' align 4

lib/AsmParser/LLToken.h

     kw_cold,
     kw_dereferenceable,
     kw_hwreg,
+    kw_noclobber,
     kw_inlinehint,
     kw_inreg,
     kw_jumptable,

lib/CodeGen/TargetRegisterInfo.cpp

 #include "llvm/CodeGen/VirtRegMap.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/IR/Function.h"
 
 using namespace llvm;
 

   dbgs() << PrintReg(Reg, TRI, SubRegIndex) << "\n";
 }
 #endif
+
+std::map<std::string, TargetRegisterInfo::MCPhysRegList> TargetRegisterInfo::ExplicitCCNoclobbers;
+
+/// getExplicitCCNoclobberList - Return a null-terminated list of all of the
+/// callee saved registers as specified for by the noclobber attribute for MF.
+const MCPhysReg
+*TargetRegisterInfo::getExplicitCCNoclobberList(const MachineFunction *MF)
+{
+  const Function *F = MF->getFunction();
+
+  if (!F->hasFnAttribute("noclobber"))
+    report_fatal_error("A function using the explicitcc calling convention "
+                       "must have a noclobber attribute");
+  std::string key = F->getFnAttribute("noclobber").getValueAsString().str();
+
+  MCPhysRegList &ls = ExplicitCCNoclobbers[key];
+  if (ls)
+    return ls;
+  const char *str = key.c_str();
+  char *end;
+  long v = strtol(str, &end, 10);
+  SmallVector<MCPhysReg, 4> NoClobbers;
+  NoClobbers.push_back(v);
+  while ((v = strtol(end, &end, 10))) {
+    NoClobbers.push_back(v);
+  }
+
+  ls = new MCPhysReg[NoClobbers.size() + 1];
+  int index = 0;
+  for (MCPhysReg r : NoClobbers)
+    ls[index++] = r;
+  ls[index] = 0;
+  return ls;
+}
+

lib/IR/Attributes.cpp

     return Result;
   }
 
-  // Convert target-dependent attributes to strings of the form:
-  //
-  //   "kind"
-  //   "kind" = "value"
-  //
-  if (isStringAttribute()) {
+  if (isStringAttribute() && getKindAsString().equals("noclobber")) {
+    // The noclobber attribute masquerade as a string attribute
+    std::string Result;
+    Result += "noclobber(";
+
+    StringRef Val = pImpl->getValueAsString();
+    size_t last = 0, next = 0;
+
+    do {
+      next = Val.find_first_of(' ', last);
+      if (last != 0 && next != StringRef::npos)
+  Result += ",";
+      Result += Val.slice(last, next);
+      last = next + 1;
+    } while (next != StringRef::npos);
+    Result += ")";
+    return Result;
+  } else if (isStringAttribute()) {
+    // Convert target-dependent attributes to strings of the form:
+    //
+    //   "kind"
+    //   "kind" = "value"
+    //
     std::string Result;
     Result += (Twine('"') + getKindAsString() + Twine('"')).str();