[TableGen] add !toupper and !tolower operators to change the casing of strings.

[zjaffal]

Remove wrong linting

[Paul-C-Anagnostopoulos]

Thanks for doing this.

Don't we want to call them !toupper and !tolower, to match C++?

[zjaffal]

In D145300#4169186, @Paul-C-Anagnostopoulos wrote:

Thanks for doing this.

Don't we want to call them !toupper and !tolower, to match C++?

yeah that would be a good idea I will update them

[zjaffal]

change bang operators to be !toupper and !tolower

[fpetrogalli]

Thank you @zjaffal for working on this.

Please update also the docs at https://llvm.org/docs/TableGen/ProgRef.html

Francesco

llvm/test/TableGen/string_ops.td

33

Unless there are compelling reasons for redirecting the test via !eq and !if, may I ask you to test the new operators directly? Something along the lines of:

class ToLower<string str> {
  string s = !tolower(str)
}

// CHECK-LABEL: def TEST1 {
// CHECK: string ="str";
// CHECK: }
def  TEST1: ToLower<"sTr">;

(something similar for !toupper)

[zjaffal]

In D145300#4170805, @fpetrogalli wrote:

Thank you @zjaffal for working on this.

Please update also the docs at https://llvm.org/docs/TableGen/ProgRef.html

Wouldn't that page be updated if I update TableGen/ProgRef.rst ?

[fpetrogalli]

In D145300#4170807, @zjaffal wrote:

In D145300#4170805, @fpetrogalli wrote:

Thank you @zjaffal for working on this.

Please update also the docs at https://llvm.org/docs/TableGen/ProgRef.html

Wouldn't that page be updated if I update TableGen/ProgRef.rst ?

Yep - my bad, I missed it. I should have taken another coffee before reviewing this patch. :)

Francesco

[zjaffal]

edit the test to check for the string instead of using !eq

[fpetrogalli]

LGTM, with a minor comments on the docs, to make somehow explicit that these new operators accept only string in input.

Thank you!

Francesco

llvm/docs/TableGen/ProgRef.rst

1634

1637

[zjaffal]

fix ProgRef.rst to indicate that the new operators only work for strings

llvm/docs/TableGen/ProgRef.rst

 ``!div(``\ *a*\ ``,`` *b*\ ``)``
     This operator preforms signed division of *a* by *b*, and produces the quotient.
     Division by 0 produces an error. Division of INT64_MIN by -1 produces an error.
 
 ``!empty(``\ *a*\ ``)``
     This operator produces 1 if the string, list, or DAG *a* is empty; 0 otherwise.
     A dag is empty if it has no arguments; the operator does not count.
 
+``!tolower(``\ *a*\ ``)``
+  This operator converts a string input *a* to lower case.
+
+``!toupper(``\ *a*\ ``)``
+  This operator converts a string input *a* to upper case.
+
 ``!eq(`` *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is equal to *b*; 0 otherwise.
     The arguments must be ``bit``, ``bits``, ``int``, ``string``, or
     record values. Use ``!cast<string>`` to compare other types of objects.
 
 ``!filter(``\ *var*\ ``,`` *list*\ ``,`` *predicate*\ ``)``
 
     This operator creates a new ``list`` by filtering the elements in

llvm/include/llvm/TableGen/Record.h

public:
 
   Init *getBit(unsigned Bit) const override;
 };
 
 /// !op (X) - Transform an init.
 ///
 class UnOpInit : public OpInit, public FoldingSetNode {
 public:
-  enum UnaryOp : uint8_t { CAST, NOT, HEAD, TAIL, SIZE, EMPTY, GETDAGOP, LOG2 };
+  enum UnaryOp : uint8_t {
+    TOLOWER,
+    TOUPPER,
+    CAST,
+    NOT,
+    HEAD,
+    TAIL,
+    SIZE,
+    EMPTY,
+    GETDAGOP,
+    LOG2
+  };
 
 private:
   Init *LHS;
 
   UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
     : OpInit(IK_UnOpInit, Type, opc), LHS(lhs) {}
 
 public:

llvm/lib/TableGen/Record.cpp

 
 void UnOpInit::Profile(FoldingSetNodeID &ID) const {
   ProfileUnOpInit(ID, getOpcode(), getOperand(), getType());
 }
 
 Init *UnOpInit::Fold(Record *CurRec, bool IsFinal) const {
   RecordKeeper &RK = getRecordKeeper();
   switch (getOpcode()) {
+  case TOLOWER:
+    if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
+      return StringInit::get(RK, LHSs->getValue().lower());
+    break;
+  case TOUPPER:
+    if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
+      return StringInit::get(RK, LHSs->getValue().upper());
+    break;
   case CAST:
     if (isa<StringRecTy>(getType())) {
       if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
         return LHSs;
 
       if (DefInit *LHSd = dyn_cast<DefInit>(LHS))
         return StringInit::get(RK, LHSd->getAsString());
 
std::string UnOpInit::getAsString() const {
   case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
   case NOT: Result = "!not"; break;
   case HEAD: Result = "!head"; break;
   case TAIL: Result = "!tail"; break;
   case SIZE: Result = "!size"; break;
   case EMPTY: Result = "!empty"; break;
   case GETDAGOP: Result = "!getdagop"; break;
   case LOG2 : Result = "!logtwo"; break;
+  case TOLOWER:
+    Result = "!tolower";
+    break;
+  case TOUPPER:
+    Result = "!toupper";
+    break;
   }
   return Result + "(" + LHS->getAsString() + ")";
 }
 
 static void
 ProfileBinOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *RHS,
                  RecTy *Type) {
   ID.AddInteger(Opcode);

llvm/lib/TableGen/TGLexer.h

 #include <vector>
 
 namespace llvm {
 template <typename T> class ArrayRef;
 class SourceMgr;
 class Twine;
 
 namespace tgtok {
-  enum TokKind {
-    // Markers
     Eof, Error,
 
-    // Tokens with no info.
     minus, plus,        // - +
     l_square, r_square, // [ ]
     l_brace, r_brace,   // { }
     l_paren, r_paren,   // ( )
     less, greater,      // < >
     colon, semi,        // : ;
     comma, dot,         // , .
     equal, question,    // = ?
     paste,              // #
     dotdotdot,          // ...
 
-    // Reserved keywords. ('ElseKW' is named to distinguish it from the
-    // existing 'Else' that means the preprocessor #else.)
     Assert, Bit, Bits, Class, Code, Dag, Def, Defm, Defset, Defvar, ElseKW,
     FalseKW, Field, Foreach, If, In, Include, Int, Let, List, MultiClass,
     String, Then, TrueKW,
 
-    // Bang operators.
     XConcat, XADD, XSUB, XMUL, XDIV, XNOT, XLOG2, XAND, XOR, XXOR, XSRA, XSRL,
     XSHL, XListConcat, XListSplat, XStrConcat, XInterleave, XSubstr, XFind,
     XCast, XSubst, XForEach, XFilter, XFoldl, XHead, XTail, XSize, XEmpty, XIf,
     XCond, XEq, XIsA, XDag, XNe, XLe, XLt, XGe, XGt, XSetDagOp, XGetDagOp,
-    XExists, XListRemove,
+    XExists, XListRemove,  XToLower, XToUpper,
 
-    // Boolean literals.
     TrueVal, FalseVal,
 
-    // Integer value.
-    IntVal,
 
-    // Binary constant.  Note that these are sized according to the number of
-    // bits given.
-    BinaryIntVal,
 
-    // String valued tokens.
     Id, StrVal, VarName, CodeFragment,
 
-    // Preprocessing tokens for internal usage by the lexer.
-    // They are never returned as a result of Lex().
     Ifdef, Ifndef, Else, Endif, Define
-  };
 }
 
 /// TGLexer - TableGen Lexer class.
 class TGLexer {
   SourceMgr &SrcMgr;
 
   const char *CurPtr = nullptr;
   StringRef CurBuf;

llvm/lib/TableGen/TGLexer.cpp

if (!isalpha(*CurPtr))
     return ReturnError(CurPtr - 1, "Invalid \"!operator\"");
 
   const char *Start = CurPtr++;
   while (isalpha(*CurPtr))
     ++CurPtr;
 
   // Check to see which operator this is.
   tgtok::TokKind Kind =
       StringSwitch<tgtok::TokKind>(StringRef(Start, CurPtr - Start))
           .Case("eq", tgtok::XEq)
           .Case("ne", tgtok::XNe)
           .Case("le", tgtok::XLe)
           .Case("lt", tgtok::XLt)
           .Case("ge", tgtok::XGe)
           .Case("gt", tgtok::XGt)
           .Case("if", tgtok::XIf)
           .Case("cond", tgtok::XCond)
           .Case("isa", tgtok::XIsA)
           .Case("head", tgtok::XHead)
           .Case("tail", tgtok::XTail)
           .Case("size", tgtok::XSize)
           .Case("con", tgtok::XConcat)
           .Case("dag", tgtok::XDag)
           .Case("add", tgtok::XADD)
           .Case("sub", tgtok::XSUB)
           .Case("mul", tgtok::XMUL)
           .Case("div", tgtok::XDIV)
           .Case("not", tgtok::XNOT)
           .Case("logtwo", tgtok::XLOG2)
           .Case("and", tgtok::XAND)
           .Case("or", tgtok::XOR)
           .Case("xor", tgtok::XXOR)
           .Case("shl", tgtok::XSHL)
           .Case("sra", tgtok::XSRA)
           .Case("srl", tgtok::XSRL)
           .Case("cast", tgtok::XCast)
           .Case("empty", tgtok::XEmpty)
           .Case("subst", tgtok::XSubst)
           .Case("foldl", tgtok::XFoldl)
           .Case("foreach", tgtok::XForEach)
           .Case("filter", tgtok::XFilter)
           .Case("listconcat", tgtok::XListConcat)
           .Case("listsplat", tgtok::XListSplat)
           .Case("listremove", tgtok::XListRemove)
           .Case("strconcat", tgtok::XStrConcat)
           .Case("interleave", tgtok::XInterleave)
           .Case("substr", tgtok::XSubstr)
           .Case("find", tgtok::XFind)
           .Cases("setdagop", "setop", tgtok::XSetDagOp) // !setop is deprecated.
           .Cases("getdagop", "getop", tgtok::XGetDagOp) // !getop is deprecated.
           .Case("exists", tgtok::XExists)
+          .Case("tolower", tgtok::XToLower)
+          .Case("toupper", tgtok::XToUpper)
           .Default(tgtok::Error);
 
   return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");
 }
 
 bool TGLexer::prepExitInclude(bool IncludeStackMustBeEmpty) {
   // Report an error, if preprocessor control stack for the current
   // file is not empty.
   if (!PrepIncludeStack.back()->empty()) {

llvm/lib/TableGen/TGParser.cpp

 /// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
 ///
 Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
   switch (Lex.getCode()) {
   default:
     TokError("unknown bang operator");
     return nullptr;
   case tgtok::XNOT:
+  case tgtok::XToLower:
+  case tgtok::XToUpper:
   case tgtok::XLOG2:
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XSize:
   case tgtok::XEmpty:
   case tgtok::XCast:
   case tgtok::XGetDagOp: { // Value ::= !unop '(' Value ')'
     UnOpInit::UnaryOp Code;
     RecTy *Type = nullptr;
 
     switch (Lex.getCode()) {
     default: llvm_unreachable("Unhandled code!");
     case tgtok::XCast:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::CAST;
 
       Type = ParseOperatorType();
 
       if (!Type) {
         TokError("did not get type for unary operator");
         return nullptr;
       }
 
       break;
+    case tgtok::XToLower:
+      Lex.Lex(); // eat the operation
+      Code = UnOpInit::TOLOWER;
+      Type = StringRecTy::get(Records);
+      break;
+    case tgtok::XToUpper:
+      Lex.Lex(); // eat the operation
+      Code = UnOpInit::TOUPPER;
+      Type = StringRecTy::get(Records);
+      break;
     case tgtok::XNOT:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::NOT;
       Type = IntRecTy::get(Records);
       break;
     case tgtok::XLOG2:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::LOG2;
case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
     return DagInit::get(Operator, OperatorName, DagArgs);
   }
 
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XSize:
   case tgtok::XEmpty:
   case tgtok::XCast:
+  case tgtok::XToLower:
+  case tgtok::XToUpper:
   case tgtok::XGetDagOp: // Value ::= !unop '(' Value ')'
   case tgtok::XExists:
   case tgtok::XIsA:
   case tgtok::XConcat:
   case tgtok::XDag:
   case tgtok::XADD:
   case tgtok::XSUB:
   case tgtok::XMUL:

llvm/test/TableGen/string_ops.td

+// RUN: llvm-tblgen %s | FileCheck %s
+
+class ToLower<string str> {
+  string s = !tolower(str);
+}
+
+class ToUpper<string str> {
+  string s = !toupper(str);
+}
+
+// CHECK-LABEL: def LOWER1 {
+// CHECK: string s = "str";
+// CHECK: }
+def LOWER1: ToLower<"STR">;
+
+// CHECK-LABEL: def LOWER2 {
+// CHECK: string s = "str";
+// CHECK: }
+def LOWER2 : ToLower<"Str">;
+
+// CHECK-LABEL: def LOWER3 {
+// CHECK: string s = "str";
+// CHECK: }
+def LOWER3 : ToLower<"STr">;
+
+// CHECK-LABEL: def UPPER1 {
+// CHECK: string s = "STR";
+// CHECK: }
+def UPPER1 : ToUpper<"str">;
+
+// CHECK-LABEL: def UPPER2 {
+// CHECK: string s = "STR";
+// CHECK: }
+def UPPER2 : ToUpper<"sTr">;
+
+// CHECK-LABEL: def UPPER3 {
+// CHECK: string s = "STR";
+// CHECK: }
+def UPPER3 : ToUpper<"sTR">;
 No newline at end of file

llvm/utils/kate/llvm-tablegen.xml

<list name="bang-operators">
       <item> !foldl </item>
       <item> !isa </item>
       <item> !dag </item>
       <item> !le </item>
       <item> !lt </item>
       <item> !ge </item>
       <item> !gt </item>
       <item> !ne </item>
+      <item> !tolower </item>
+      <item> !toupper </item>
     </list>
     <list name="objects">
       <item> class </item>
       <item> def </item>
       <item> defm </item>
       <item> defset </item>
       <item> let </item>
       <item> defvar </item>