Add bitwise operators and propagate them from parser -> halide -> isl

Author: prigoyal

tc/core/tc2halide.cc

@@ -190,6 +190,18 @@ Expr translateExpr(
       return t(0) && t(1);
     case lang::TK_OR:
       return t(0) || t(1);
+    case lang::TK_LS:
+      return t(0) << t(1);
+    case lang::TK_RS:
+      return t(0) >> t(1);
+    case '|':
+      return t(0) | t(1);
+    case '^':
+      return t(0) ^ t(1);
+    case '&':
+      return t(0) & t(1);
+    case '~':
+      return ~t(0);
     case lang::TK_BUILT_IN: {
       auto b = lang::BuiltIn(expr);
       vector<Expr> exprs;

tc/lang/lexer.h

@@ -84,10 +84,12 @@ namespace lang {
   _(TK_NE, "neq", "!=")                          \
   _(TK_AND, "and", "&&")                         \
   _(TK_OR, "or", "||")                           \
+  _(TK_LS, "ls", "<<")                           \
+  _(TK_RS, "rs", ">>")                           \
   _(TK_LET, "let", "")                           \
   _(TK_EXISTS, "exists", "exists")
 
-static const char* valid_single_char_tokens = "+-*/()[]?:,={}><!%";
+static const char* valid_single_char_tokens = "+-*/()[]?:,={}><!%&^|~";
 
 enum TokenKind {
   // we use characters to represent themselves so skip all valid characters
@@ -135,12 +137,16 @@ struct SharedParserData {
         {'?'},
         {TK_OR},
         {TK_AND},
+        {'|'},
+        {'^'},
+        {'&'},
         {'>', '<', TK_LE, TK_GE, TK_EQ, TK_NE},
+        {TK_LS, TK_RS},
         {'+', '-'},
         {'*', '/', '%'},
     };
     std::vector<std::vector<int>> unary_ops = {
-        {'-', '!'},
+        {'-', '!', '~'},
     };
 
     std::stringstream ss;

tc/lang/test_expected/bitwise.expected

@@ -0,0 +1,11 @@
+(|
+  (^
+    (&
+      (~ (const 3 (int32)))
+      (const 4 (int32)))
+    (const 5 (int32)))
+  (ls
+    (rs
+      (const 6 (int32))
+      (const 8 (int32)))
+    (const 2 (int32))))

test/test_lang.cc

@@ -244,6 +244,14 @@ int main(int argc, char** argv) {
     ss2 << p2.parseExp();
     assertEqual("function.expected", ss2.str());
   }
+  {
+    std::string bitOps = "~3&4^5|6>>8<<2";
+    Parser p(bitOps);
+    auto r = p.parseExp();
+    std::stringstream ss;
+    ss << r;
+    assertEqual("bitwise.expected", ss.str());
+  }
   assertParseEqual("trinary.expected", "a ? 3 : b ? 3 : 4", [&](Parser& p) {
     return p.parseExp();
   });