Re-implemented bitslice/sext/zext #52

mathis-s · 2025-03-05T01:45:34Z

No description provided.

github-actions · 2025-03-05T01:47:17Z

Cpp-Linter Report ⚠️

Some files did not pass the configured checks!

clang-tidy (v12.0.0) reports: 356 concern(s)

llvm/lib/CodeGen/GlobalISel/PatternGen.cpp:700:42: warning: [readability-identifier-naming]

invalid case style for parameter 'p'

  static bool classof(const PatternNode *p) { return p->getKind() == PN_Load; }
                                         ^           ~
                                         P           P

llvm/lib/CodeGen/GlobalISel/PatternGen.cpp:714:42: warning: [readability-identifier-naming]

invalid case style for parameter 'p'

  static bool classof(const PatternNode *p) { return p->getKind() == PN_Cast; }
                                         ^           ~
                                         P           P

llvm/lib/CodeGen/GlobalISel/PatternGen.cpp:742:42: warning: [readability-identifier-naming]

invalid case style for parameter 'p'

  static bool classof(const PatternNode *p) { return p->getKind() == PN_Cast; }
                                         ^           ~
                                         P           P

llvm/lib/CodeGen/GlobalISel/PatternGen.cpp:749:23: warning: [readability-identifier-naming]

invalid case style for function 'PError'
```
static PatternOrError PError(PatternError Error) {
                      ^~~~~~
                      pError
```
llvm/lib/CodeGen/GlobalISel/PatternGen.cpp:752:23: warning: [readability-identifier-naming]

invalid case style for function 'PError'
```
static PatternOrError PError(PatternErrorT Type) {
                      ^~~~~~
                      pError
```

llvm/lib/CodeGen/GlobalISel/PatternGen.cpp:755:23: warning: [readability-identifier-naming]

invalid case style for function 'PPattern'

static PatternOrError PPattern(std::unique_ptr<PatternNode> Pattern) {
                      ^~~~~~~~
                      pPattern

llvm/tools/pattern-gen/lib/Parser.cpp:43:16: warning: [readability-identifier-naming]

invalid case style for member 'll'
```
  llvm::Value *ll;
               ^~
               Ll
```
llvm/tools/pattern-gen/lib/Parser.cpp:44:7: warning: [readability-identifier-naming]

invalid case style for member 'bitWidth'
```
  int bitWidth;
      ^~~~~~~~
      BitWidth
```
llvm/tools/pattern-gen/lib/Parser.cpp:45:8: warning: [readability-identifier-naming]

invalid case style for member 'isSigned'
```
  bool isSigned;
       ^~~~~~~~
       IsSigned
```
llvm/tools/pattern-gen/lib/Parser.cpp:46:8: warning: [readability-identifier-naming]

invalid case style for member 'isLValue'
```
  bool isLValue;
       ^~~~~~~~
       IsLValue
```
llvm/tools/pattern-gen/lib/Parser.cpp:48:22: warning: [readability-identifier-naming]

invalid case style for parameter 'llvalue'
```
  Value(llvm::Value *llvalue, bool isSigned = false)
                     ^~~~~~~
                     Llvalue
```

llvm/tools/pattern-gen/lib/Parser.cpp:48:36: warning: [readability-identifier-naming]

invalid case style for parameter 'isSigned'

  Value(llvm::Value *llvalue, bool isSigned = false)
                                   ^~~~~~~~
                                   IsSigned

llvm/tools/pattern-gen/lib/Parser.cpp:55:22: warning: [readability-identifier-naming]

invalid case style for parameter 'llvalue'

  Value(llvm::Value *llvalue, int bitWidth, bool isSigned = false)
                     ^~~~~~~
                     Llvalue

llvm/tools/pattern-gen/lib/Parser.cpp:55:35: warning: [readability-identifier-naming]

invalid case style for parameter 'bitWidth'

  Value(llvm::Value *llvalue, int bitWidth, bool isSigned = false)
                                  ^~~~~~~~
                                  BitWidth

llvm/tools/pattern-gen/lib/Parser.cpp:55:50: warning: [readability-identifier-naming]

invalid case style for parameter 'isSigned'

  Value(llvm::Value *llvalue, int bitWidth, bool isSigned = false)
                                                 ^~~~~~~~
                                                 IsSigned

llvm/tools/pattern-gen/lib/Parser.cpp:63:9: warning: [readability-identifier-naming]

invalid case style for member 'val'
```
  Value val;
        ^~~
        Val
```
llvm/tools/pattern-gen/lib/Parser.cpp:64:7: warning: [readability-identifier-naming]

invalid case style for member 'scope'
```
  int scope;
      ^~~~~
      Scope
```

llvm/tools/pattern-gen/lib/Parser.cpp:66:62: warning: [readability-identifier-naming]

invalid case style for variable 'variables'

static llvm::DenseMap<uint32_t, llvm::SmallVector<Variable>> variables;
                                                             ^~~~~~~~~
                                                             Variables

llvm/tools/pattern-gen/lib/Parser.cpp:67:12: warning: [readability-identifier-naming]

invalid case style for variable 'scopeDepth'
```
static int scopeDepth;
           ^~~~~~~~~~
           ScopeDepth
```
llvm/tools/pattern-gen/lib/Parser.cpp:68:26: warning: [readability-identifier-naming]

invalid case style for variable 'entry'
```
static llvm::BasicBlock *entry;
                         ^~~~~
                         Entry
```
llvm/tools/pattern-gen/lib/Parser.cpp:69:19: warning: [readability-identifier-naming]

invalid case style for variable 'curInstr'
```
static CDSLInstr *curInstr;
                  ^~~~~~~~
                  CurInstr
```
llvm/tools/pattern-gen/lib/Parser.cpp:71:12: warning: [readability-identifier-naming]

invalid case style for variable 'xlen'
```
static int xlen;
           ^~~~
           Xlen
```
llvm/tools/pattern-gen/lib/Parser.cpp:72:13: warning: [readability-identifier-naming]

invalid case style for variable 'NoExtend_'
```
static bool NoExtend_;
            ^~~~~~~~~
            NoExtend
```
llvm/tools/pattern-gen/lib/Parser.cpp:73:20: warning: [readability-identifier-naming]

invalid case style for variable 'regT'
```
static llvm::Type *regT;
                   ^~~~
                   RegT
```
llvm/tools/pattern-gen/lib/Parser.cpp:75:13: warning: [readability-identifier-naming]

invalid case style for function 'reset_globals'
```
static void reset_globals() {
            ^~~~~~~~~~~~~
            resetGlobals
```
llvm/tools/pattern-gen/lib/Parser.cpp:82:13: warning: [readability-identifier-naming]

invalid case style for function 'create_var_scope'
```
static void create_var_scope() { scopeDepth++; }
            ^~~~~~~~~~~~~~~~
            createVarScope
```
llvm/tools/pattern-gen/lib/Parser.cpp:84:13: warning: [readability-identifier-naming]

invalid case style for function 'pop_var_scope'
```
static void pop_var_scope() {
            ^~~~~~~~~~~~~
            popVarScope
```
llvm/tools/pattern-gen/lib/Parser.cpp:96:6: warning: [readability-identifier-naming]

invalid case style for function 'ParseScope'
```
void ParseScope(TokenStream &ts, llvm::Function *func,
     ^~~~~~~~~~
     parseScope
```
llvm/tools/pattern-gen/lib/Parser.cpp:96:30: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'
```
void ParseScope(TokenStream &ts, llvm::Function *func,
                             ^~
                             Ts
```

llvm/tools/pattern-gen/lib/Parser.cpp:96:50: warning: [readability-identifier-naming]

invalid case style for parameter 'func'

void ParseScope(TokenStream &ts, llvm::Function *func,
                                                 ^~~~
                                                 Func

llvm/tools/pattern-gen/lib/Parser.cpp:97:36: warning: [readability-identifier-naming]

invalid case style for parameter 'build'

                llvm::IRBuilder<> &build);
                                   ^~~~~
                                   Build

llvm/tools/pattern-gen/lib/Parser.cpp:98:7: warning: [readability-identifier-naming]

invalid case style for function 'ParseExpression'
```
Value ParseExpression(TokenStream &ts, llvm::Function *func,
      ^~~~~~~~~~~~~~~
      parseExpression
```

llvm/tools/pattern-gen/lib/Parser.cpp:98:36: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

Value ParseExpression(TokenStream &ts, llvm::Function *func,
                                   ^~
                                   Ts

llvm/tools/pattern-gen/lib/Parser.cpp:98:56: warning: [readability-identifier-naming]

invalid case style for parameter 'func'

Value ParseExpression(TokenStream &ts, llvm::Function *func,
                                                       ^~~~
                                                       Func

llvm/tools/pattern-gen/lib/Parser.cpp:99:42: warning: [readability-identifier-naming]

invalid case style for parameter 'build'

                      llvm::IRBuilder<> &build, int minPrec = 0);
                                         ^~~~~
                                         Build

llvm/tools/pattern-gen/lib/Parser.cpp:99:53: warning: [readability-identifier-naming]

invalid case style for parameter 'minPrec'

                      llvm::IRBuilder<> &build, int minPrec = 0);
                                                    ^~~~~~~
                                                    MinPrec

llvm/tools/pattern-gen/lib/Parser.cpp:101:57: warning: [readability-identifier-naming]

invalid case style for parameter 'msg'

static void __attribute__((noreturn)) error(const char *msg, TokenStream &ts) {
                                                        ^~~
                                                        Msg

llvm/tools/pattern-gen/lib/Parser.cpp:101:75: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

static void __attribute__((noreturn)) error(const char *msg, TokenStream &ts) {
                                                                          ^~
                                                                          Ts

llvm/tools/pattern-gen/lib/Parser.cpp:106:33: warning: [readability-identifier-naming]

invalid case style for parameter 'msg'

static void warning(const char *msg, TokenStream &ts) {
                                ^~~
                                Msg

llvm/tools/pattern-gen/lib/Parser.cpp:106:51: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

static void warning(const char *msg, TokenStream &ts) {
                                                  ^~
                                                  Ts

llvm/tools/pattern-gen/lib/Parser.cpp:110:39: warning: [readability-identifier-naming]

invalid case style for function 'syntax_error'

static void __attribute__((noreturn)) syntax_error(TokenStream &ts) {
                                      ^~~~~~~~~~~~
                                      syntaxError

llvm/tools/pattern-gen/lib/Parser.cpp:110:65: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

static void __attribute__((noreturn)) syntax_error(TokenStream &ts) {
                                                                ^~
                                                                Ts

llvm/tools/pattern-gen/lib/Parser.cpp:114:13: warning: [readability-identifier-naming]

invalid case style for function 'implicit_truncation'
```
static void implicit_truncation(TokenStream &ts) {
            ^~~~~~~~~~~~~~~~~~~
            implicitTruncation
```

llvm/tools/pattern-gen/lib/Parser.cpp:114:46: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

static void implicit_truncation(TokenStream &ts) {
                                             ^~
                                             Ts

llvm/tools/pattern-gen/lib/Parser.cpp:118:39: warning: [readability-identifier-naming]

invalid case style for function 'not_implemented'

static void __attribute__((noreturn)) not_implemented(TokenStream &ts) {
                                      ^~~~~~~~~~~~~~~
                                      notImplemented

llvm/tools/pattern-gen/lib/Parser.cpp:118:68: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

static void __attribute__((noreturn)) not_implemented(TokenStream &ts) {
                                                                   ^~
                                                                   Ts

llvm/tools/pattern-gen/lib/Parser.cpp:122:13: warning: [readability-identifier-naming]

invalid case style for function 'add_variable'
```
static void add_variable(TokenStream ts, int identIdx, Value v) {
            ^~~~~~~~~~~~
            addVariable
```

llvm/tools/pattern-gen/lib/Parser.cpp:122:38: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

static void add_variable(TokenStream ts, int identIdx, Value v) {
                                     ^~
                                     Ts

llvm/tools/pattern-gen/lib/Parser.cpp:122:46: warning: [readability-identifier-naming]

invalid case style for parameter 'identIdx'

static void add_variable(TokenStream ts, int identIdx, Value v) {
                                             ^~~~~~~~
                                             IdentIdx

llvm/tools/pattern-gen/lib/Parser.cpp:122:62: warning: [readability-identifier-naming]

invalid case style for parameter 'v'

static void add_variable(TokenStream ts, int identIdx, Value v) {
                                                             ^
                                                             V

llvm/tools/pattern-gen/lib/Parser.cpp:130:14: warning: [readability-identifier-naming]

invalid case style for function 'pop_cur'
```
static Token pop_cur(TokenStream &ts, TokenType expected) {
             ^~~~~~~
             popCur
```

llvm/tools/pattern-gen/lib/Parser.cpp:130:35: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

static Token pop_cur(TokenStream &ts, TokenType expected) {
                                  ^~
                                  Ts

llvm/tools/pattern-gen/lib/Parser.cpp:130:49: warning: [readability-identifier-naming]

invalid case style for parameter 'expected'

static Token pop_cur(TokenStream &ts, TokenType expected) {
                                                ^~~~~~~~
                                                Expected

llvm/tools/pattern-gen/lib/Parser.cpp:131:9: warning: [readability-identifier-naming]

invalid case style for variable 't'
```
  Token t = ts.Pop();
        ^
        T
```
llvm/tools/pattern-gen/lib/Parser.cpp:137:13: warning: [readability-identifier-naming]

invalid case style for function 'pop_cur_if'
```
static bool pop_cur_if(TokenStream &ts, TokenType expected) {
            ^~~~~~~~~~
            popCurIf
```

llvm/tools/pattern-gen/lib/Parser.cpp:137:37: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

static bool pop_cur_if(TokenStream &ts, TokenType expected) {
                                    ^~
                                    Ts

llvm/tools/pattern-gen/lib/Parser.cpp:137:51: warning: [readability-identifier-naming]

invalid case style for parameter 'expected'

static bool pop_cur_if(TokenStream &ts, TokenType expected) {
                                                  ^~~~~~~~
                                                  Expected

llvm/tools/pattern-gen/lib/Parser.cpp:138:9: warning: [readability-identifier-naming]

invalid case style for variable 't'
```
  Token t = ts.Peek();
        ^
        T
```
llvm/tools/pattern-gen/lib/Parser.cpp:146:13: warning: [readability-identifier-naming]

invalid case style for function 'peek_is_type'
```
static bool peek_is_type(TokenStream &ts) {
            ^~~~~~~~~~~~
            peekIsType
```

llvm/tools/pattern-gen/lib/Parser.cpp:146:39: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

static bool peek_is_type(TokenStream &ts) {
                                      ^~
                                      Ts

llvm/tools/pattern-gen/lib/Parser.cpp:147:8: warning: [readability-identifier-naming]

invalid case style for variable 'peekT'
```
  auto peekT = ts.Peek().type;
       ^~~~~
       PeekT
```
llvm/tools/pattern-gen/lib/Parser.cpp:152:12: warning: [readability-identifier-naming]

invalid case style for function 'ceil_to_pow2'
```
static int ceil_to_pow2(int n) {
           ^~~~~~~~~~~~
           ceilToPow2
```
llvm/tools/pattern-gen/lib/Parser.cpp:152:29: warning: [readability-identifier-naming]

invalid case style for parameter 'n'
```
static int ceil_to_pow2(int n) {
                            ^
                            N
```
llvm/tools/pattern-gen/lib/Parser.cpp:153:7: warning: [readability-identifier-naming]

invalid case style for variable 'bitWidth8'
```
  int bitWidth8 = (((n + 7) / 8) * 8);
      ^~~~~~~~~
      BitWidth8
```
llvm/tools/pattern-gen/lib/Parser.cpp:154:7: warning: [readability-identifier-naming]

invalid case style for variable 'bitWidth2'
```
  int bitWidth2 = 1 << (31 - __builtin_clz(bitWidth8));
      ^~~~~~~~~
      BitWidth2
```
llvm/tools/pattern-gen/lib/Parser.cpp:160:6: warning: [readability-identifier-naming]

invalid case style for function 'promote_lvalue'
```
void promote_lvalue(llvm::IRBuilder<> &build, Value &v) {
     ^~~~~~~~~~~~~~
     promoteLvalue
```

llvm/tools/pattern-gen/lib/Parser.cpp:160:40: warning: [readability-identifier-naming]

invalid case style for parameter 'build'

void promote_lvalue(llvm::IRBuilder<> &build, Value &v) {
                                       ^~~~~
                                       Build

llvm/tools/pattern-gen/lib/Parser.cpp:160:54: warning: [readability-identifier-naming]

invalid case style for parameter 'v'

void promote_lvalue(llvm::IRBuilder<> &build, Value &v) {
                                                     ^
                                                     V

llvm/tools/pattern-gen/lib/Parser.cpp:170:13: warning: [readability-identifier-naming]

invalid case style for function 'fit_to_size'
```
static void fit_to_size(Value &v, llvm::IRBuilder<> &build) {
            ^~~~~~~~~~~
            fitToSize
```

llvm/tools/pattern-gen/lib/Parser.cpp:170:32: warning: [readability-identifier-naming]

invalid case style for parameter 'v'

static void fit_to_size(Value &v, llvm::IRBuilder<> &build) {
                               ^
                               V

llvm/tools/pattern-gen/lib/Parser.cpp:170:54: warning: [readability-identifier-naming]

invalid case style for parameter 'build'

static void fit_to_size(Value &v, llvm::IRBuilder<> &build) {
                                                     ^~~~~
                                                     Build

llvm/tools/pattern-gen/lib/Parser.cpp:171:8: warning: [readability-identifier-naming]

invalid case style for variable 'sExt'
```
  bool sExt = v.isSigned;
       ^~~~
       SExt
```
llvm/tools/pattern-gen/lib/Parser.cpp:172:9: warning: [readability-identifier-naming]

invalid case style for variable 'ctx'
```
  auto &ctx = build.getContext();
        ^~~
        Ctx
```
llvm/tools/pattern-gen/lib/Parser.cpp:174:15: warning: [readability-identifier-naming]

invalid case style for variable 'newType'
```
  llvm::Type *newType = llvm::Type::getIntNTy(ctx, v.bitWidth);
              ^~~~~~~
              NewType
```
llvm/tools/pattern-gen/lib/Parser.cpp:185:7: warning: [readability-identifier-naming]

invalid case style for function 'gen_subscript'
```
Value gen_subscript(TokenStream &ts, llvm::Function *func,
      ^~~~~~~~~~~~~
      genSubscript
```

llvm/tools/pattern-gen/lib/Parser.cpp:185:34: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

Value gen_subscript(TokenStream &ts, llvm::Function *func,
                                 ^~
                                 Ts

llvm/tools/pattern-gen/lib/Parser.cpp:185:54: warning: [readability-identifier-naming]

invalid case style for parameter 'func'

Value gen_subscript(TokenStream &ts, llvm::Function *func,
                                                     ^~~~
                                                     Func

llvm/tools/pattern-gen/lib/Parser.cpp:186:40: warning: [readability-identifier-naming]

invalid case style for parameter 'build'

                    llvm::IRBuilder<> &build, TokenType op, Value left,
                                       ^~~~~
                                       Build

llvm/tools/pattern-gen/lib/Parser.cpp:186:57: warning: [readability-identifier-naming]

invalid case style for parameter 'op'

                    llvm::IRBuilder<> &build, TokenType op, Value left,
                                                        ^~
                                                        Op

llvm/tools/pattern-gen/lib/Parser.cpp:186:67: warning: [readability-identifier-naming]

invalid case style for parameter 'left'

                    llvm::IRBuilder<> &build, TokenType op, Value left,
                                                                  ^~~~
                                                                  Left

llvm/tools/pattern-gen/lib/Parser.cpp:187:27: warning: [readability-identifier-naming]

invalid case style for parameter 'right'
```
                    Value right) {
                          ^~~~~
                          Right
```
llvm/tools/pattern-gen/lib/Parser.cpp:188:9: warning: [readability-identifier-naming]

invalid case style for variable 'ctx'
```
  auto &ctx = func->getContext();
        ^~~
        Ctx
```
llvm/tools/pattern-gen/lib/Parser.cpp:189:9: warning: [readability-identifier-naming]

invalid case style for variable 'upper'
```
  Value upper = ParseExpression(ts, func, build);
        ^~~~~
        Upper
```
llvm/tools/pattern-gen/lib/Parser.cpp:191:7: warning: [readability-identifier-naming]

invalid case style for variable 'len'
```
  int len = 0;
      ^~~
      Len
```
llvm/tools/pattern-gen/lib/Parser.cpp:192:9: warning: [readability-identifier-naming]

invalid case style for variable 'lower'
```
  Value lower;
        ^~~~~
        Lower
```
llvm/tools/pattern-gen/lib/Parser.cpp:231:10: warning: [readability-identifier-naming]

invalid case style for variable 'offset'
```
    auto offset = build.CreateUDiv(
         ^~~~~~
         Offset
```
llvm/tools/pattern-gen/lib/Parser.cpp:236:10: warning: [readability-identifier-naming]

invalid case style for variable 'llptr'
```
    auto llptr =
         ^~~~~
         Llptr
```
llvm/tools/pattern-gen/lib/Parser.cpp:249:10: warning: [readability-identifier-naming]

invalid case style for variable 'ec'
```
    auto ec = llvm::ElementCount::getFixed(xlen / len);
         ^~
         Ec
```
llvm/tools/pattern-gen/lib/Parser.cpp:253:11: warning: [readability-identifier-naming]

invalid case style for variable 'idx'
```
    auto *idx = build.CreateUDiv(lower.ll, llvm::ConstantInt::get(regT, len));
          ^~~
          Idx
```
llvm/tools/pattern-gen/lib/Parser.cpp:267:9: warning: [readability-identifier-naming]

invalid case style for variable 'llLen'
```
    int llLen = upper.ll->getType()->getIntegerBitWidth();
        ^~~~~
        LlLen
```
llvm/tools/pattern-gen/lib/Parser.cpp:268:18: warning: [readability-identifier-naming]

invalid case style for variable 'mask'
```
    llvm::Value *mask =
                 ^~~~
                 Mask
```
llvm/tools/pattern-gen/lib/Parser.cpp:283:6: warning: [readability-identifier-naming]

invalid case style for function 'check_lvalue'
```
void check_lvalue(Value &v, TokenStream &ts, llvm::BasicBlock *bb) {
     ^~~~~~~~~~~~
     checkLvalue
```

llvm/tools/pattern-gen/lib/Parser.cpp:283:26: warning: [readability-identifier-naming]

invalid case style for parameter 'v'

void check_lvalue(Value &v, TokenStream &ts, llvm::BasicBlock *bb) {
                         ^
                         V

llvm/tools/pattern-gen/lib/Parser.cpp:283:42: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

void check_lvalue(Value &v, TokenStream &ts, llvm::BasicBlock *bb) {
                                         ^~
                                         Ts

llvm/tools/pattern-gen/lib/Parser.cpp:283:64: warning: [readability-identifier-naming]

invalid case style for parameter 'bb'

void check_lvalue(Value &v, TokenStream &ts, llvm::BasicBlock *bb) {
                                                               ^~
                                                               Bb

llvm/tools/pattern-gen/lib/Parser.cpp:287:16: warning: [readability-identifier-naming]

invalid case style for variable 'll'
```
  llvm::Value *ll = v.ll;
               ^~
               Ll
```
llvm/tools/pattern-gen/lib/Parser.cpp:303:7: warning: [readability-identifier-naming]

invalid case style for function 'gen_assign'
```
Value gen_assign(TokenStream &ts, llvm::Function *func,
      ^~~~~~~~~~
      genAssign
```

llvm/tools/pattern-gen/lib/Parser.cpp:303:31: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

Value gen_assign(TokenStream &ts, llvm::Function *func,
                              ^~
                              Ts

llvm/tools/pattern-gen/lib/Parser.cpp:303:51: warning: [readability-identifier-naming]

invalid case style for parameter 'func'

Value gen_assign(TokenStream &ts, llvm::Function *func,
                                                  ^~~~
                                                  Func

llvm/tools/pattern-gen/lib/Parser.cpp:304:37: warning: [readability-identifier-naming]

invalid case style for parameter 'build'

                 llvm::IRBuilder<> &build, TokenType op, Value left,
                                    ^~~~~
                                    Build

llvm/tools/pattern-gen/lib/Parser.cpp:304:54: warning: [readability-identifier-naming]

invalid case style for parameter 'op'

                 llvm::IRBuilder<> &build, TokenType op, Value left,
                                                     ^~
                                                     Op

llvm/tools/pattern-gen/lib/Parser.cpp:304:64: warning: [readability-identifier-naming]

invalid case style for parameter 'left'

                 llvm::IRBuilder<> &build, TokenType op, Value left,
                                                               ^~~~
                                                               Left

llvm/tools/pattern-gen/lib/Parser.cpp:305:24: warning: [readability-identifier-naming]

invalid case style for parameter 'right'
```
                 Value right) {
                       ^~~~~
                       Right
```
llvm/tools/pattern-gen/lib/Parser.cpp:306:9: warning: [readability-identifier-naming]

invalid case style for variable 'ctx'
```
  auto &ctx = func->getContext();
        ^~~
        Ctx
```
llvm/tools/pattern-gen/lib/Parser.cpp:313:9: warning: [readability-identifier-naming]

invalid case style for variable 'rightOriginal'
```
  Value rightOriginal = right;
        ^~~~~~~~~~~~~
        RightOriginal
```
llvm/tools/pattern-gen/lib/Parser.cpp:325:7: warning: [readability-identifier-naming]

invalid case style for function 'gen_compare'
```
Value gen_compare(TokenStream &ts, llvm::Function *func,
      ^~~~~~~~~~~
      genCompare
```

llvm/tools/pattern-gen/lib/Parser.cpp:325:32: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

Value gen_compare(TokenStream &ts, llvm::Function *func,
                               ^~
                               Ts

llvm/tools/pattern-gen/lib/Parser.cpp:325:52: warning: [readability-identifier-naming]

invalid case style for parameter 'func'

Value gen_compare(TokenStream &ts, llvm::Function *func,
                                                   ^~~~
                                                   Func

llvm/tools/pattern-gen/lib/Parser.cpp:326:38: warning: [readability-identifier-naming]

invalid case style for parameter 'build'

                  llvm::IRBuilder<> &build, TokenType op, Value left,
                                     ^~~~~
                                     Build

llvm/tools/pattern-gen/lib/Parser.cpp:326:55: warning: [readability-identifier-naming]

invalid case style for parameter 'op'

                  llvm::IRBuilder<> &build, TokenType op, Value left,
                                                      ^~
                                                      Op

llvm/tools/pattern-gen/lib/Parser.cpp:326:65: warning: [readability-identifier-naming]

invalid case style for parameter 'left'

                  llvm::IRBuilder<> &build, TokenType op, Value left,
                                                                ^~~~
                                                                Left

llvm/tools/pattern-gen/lib/Parser.cpp:327:25: warning: [readability-identifier-naming]

invalid case style for parameter 'right'
```
                  Value right) {
                        ^~~~~
                        Right
```
llvm/tools/pattern-gen/lib/Parser.cpp:333:19: warning: [readability-identifier-naming]

invalid case style for variable 'conv'
```
  static const Op conv[] = {
                  ^~~~
                  Conv
```
llvm/tools/pattern-gen/lib/Parser.cpp:349:6: warning: [readability-identifier-naming]

invalid case style for variable 'llop'
```
  Op llop = conv[op];
     ^~~~
     Llop
```
llvm/tools/pattern-gen/lib/Parser.cpp:355:8: warning: [readability-identifier-naming]

invalid case style for variable 'signedCmp'
```
  bool signedCmp = left.isSigned || right.isSigned;
       ^~~~~~~~~
       SignedCmp
```
llvm/tools/pattern-gen/lib/Parser.cpp:374:7: warning: [readability-identifier-naming]

invalid case style for variable 'compareWidth'
```
  int compareWidth = std::max(left.bitWidth, right.bitWidth);
      ^~~~~~~~~~~~
      CompareWidth
```
llvm/tools/pattern-gen/lib/Parser.cpp:380:9: warning: [readability-identifier-naming]

invalid case style for variable 'result'
```
  Value result;
        ^~~~~~
        Result
```
llvm/tools/pattern-gen/lib/Parser.cpp:388:7: warning: [readability-identifier-naming]

invalid case style for function 'gen_binop'
```
Value gen_binop(TokenStream &ts, llvm::Function *func, llvm::IRBuilder<> &build,
      ^~~~~~~~~
      genBinop
```

llvm/tools/pattern-gen/lib/Parser.cpp:388:30: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

Value gen_binop(TokenStream &ts, llvm::Function *func, llvm::IRBuilder<> &build,
                             ^~
                             Ts

llvm/tools/pattern-gen/lib/Parser.cpp:388:50: warning: [readability-identifier-naming]

invalid case style for parameter 'func'

Value gen_binop(TokenStream &ts, llvm::Function *func, llvm::IRBuilder<> &build,
                                                 ^~~~
                                                 Func

llvm/tools/pattern-gen/lib/Parser.cpp:388:75: warning: [readability-identifier-naming]

invalid case style for parameter 'build'

Value gen_binop(TokenStream &ts, llvm::Function *func, llvm::IRBuilder<> &build,
                                                                          ^~~~~
                                                                          Build

llvm/tools/pattern-gen/lib/Parser.cpp:389:27: warning: [readability-identifier-naming]

invalid case style for parameter 'op'

                TokenType op, Value left, Value right) {
                          ^~
                          Op

llvm/tools/pattern-gen/lib/Parser.cpp:389:37: warning: [readability-identifier-naming]

invalid case style for parameter 'left'

                TokenType op, Value left, Value right) {
                                    ^~~~
                                    Left

llvm/tools/pattern-gen/lib/Parser.cpp:389:49: warning: [readability-identifier-naming]

invalid case style for parameter 'right'

                TokenType op, Value left, Value right) {
                                                ^~~~~
                                                Right

llvm/tools/pattern-gen/lib/Parser.cpp:391:9: warning: [readability-identifier-naming]

invalid case style for variable 'ctx'
```
  auto &ctx = func->getContext();
        ^~~
        Ctx
```
llvm/tools/pattern-gen/lib/Parser.cpp:393:9: warning: [readability-identifier-naming]

invalid case style for variable 'leftOriginal'
```
  Value leftOriginal = left;
        ^~~~~~~~~~~~
        LeftOriginal
```
llvm/tools/pattern-gen/lib/Parser.cpp:397:30: warning: [readability-identifier-naming]

invalid case style for variable 'conv'
```
  static const Op::BinaryOps conv[] = {
                             ^~~~
                             Conv
```

llvm/tools/pattern-gen/lib/Parser.cpp:432:35: warning: [readability-identifier-naming]

invalid case style for variable 'llop'

  llvm::BinaryOperator::BinaryOps llop = conv[op];
                                  ^~~~
                                  Llop

llvm/tools/pattern-gen/lib/Parser.cpp:434:8: warning: [readability-identifier-naming]

invalid case style for variable 'outSigned'
```
  bool outSigned;
       ^~~~~~~~~
       OutSigned
```
llvm/tools/pattern-gen/lib/Parser.cpp:449:7: warning: [readability-identifier-naming]

invalid case style for variable 'w1'
```
  int w1 = left.bitWidth;
      ^~
      W1
```
llvm/tools/pattern-gen/lib/Parser.cpp:450:7: warning: [readability-identifier-naming]

invalid case style for variable 'w2'
```
  int w2 = right.bitWidth;
      ^~
      W2
```
llvm/tools/pattern-gen/lib/Parser.cpp:451:7: warning: [readability-identifier-naming]

invalid case style for variable 'signedPair'
```
  int signedPair = (left.isSigned << 1) | right.isSigned;
      ^~~~~~~~~~
      SignedPair
```
llvm/tools/pattern-gen/lib/Parser.cpp:453:7: warning: [readability-identifier-naming]

invalid case style for variable 'resultWidth'
```
  int resultWidth;
      ^~~~~~~~~~~
      ResultWidth
```
llvm/tools/pattern-gen/lib/Parser.cpp:540:8: warning: [readability-identifier-naming]

invalid case style for variable 'v'
```
  auto v = Value(build.CreateBinOp(llop, left.ll, right.ll), outSigned);
       ^
       V
```
llvm/tools/pattern-gen/lib/Parser.cpp:547:7: warning: [readability-identifier-naming]

invalid case style for function 'gen_ternary_relaxed'
```
Value gen_ternary_relaxed(TokenStream &ts, llvm::Function *func,
      ^~~~~~~~~~~~~~~~~~~
      genTernaryRelaxed
```

llvm/tools/pattern-gen/lib/Parser.cpp:547:40: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

Value gen_ternary_relaxed(TokenStream &ts, llvm::Function *func,
                                       ^~
                                       Ts

llvm/tools/pattern-gen/lib/Parser.cpp:547:60: warning: [readability-identifier-naming]

invalid case style for parameter 'func'

Value gen_ternary_relaxed(TokenStream &ts, llvm::Function *func,
                                                           ^~~~
                                                           Func

llvm/tools/pattern-gen/lib/Parser.cpp:548:46: warning: [readability-identifier-naming]

invalid case style for parameter 'build'

                          llvm::IRBuilder<> &build, TokenType op, Value left,
                                             ^~~~~
                                             Build

llvm/tools/pattern-gen/lib/Parser.cpp:548:63: warning: [readability-identifier-naming]

invalid case style for parameter 'op'

                          llvm::IRBuilder<> &build, TokenType op, Value left,
                                                              ^~
                                                              Op

llvm/tools/pattern-gen/lib/Parser.cpp:548:73: warning: [readability-identifier-naming]

invalid case style for parameter 'left'

                          llvm::IRBuilder<> &build, TokenType op, Value left,
                                                                        ^~~~
                                                                        Left

llvm/tools/pattern-gen/lib/Parser.cpp:549:33: warning: [readability-identifier-naming]

invalid case style for parameter 'right'

                          Value right) {
                                ^~~~~
                                Right

llvm/tools/pattern-gen/lib/Parser.cpp:556:8: warning: [readability-identifier-naming]

invalid case style for variable 'valTrue'
```
  auto valTrue = ParseExpression(ts, func, build);
       ^~~~~~~
       ValTrue
```
llvm/tools/pattern-gen/lib/Parser.cpp:558:8: warning: [readability-identifier-naming]

invalid case style for variable 'valFalse'
```
  auto valFalse = ParseExpression(ts, func, build);
       ^~~~~~~~
       ValFalse
```
llvm/tools/pattern-gen/lib/Parser.cpp:564:8: warning: [readability-identifier-naming]

invalid case style for variable 'cond'
```
  auto cond = build.CreateICmpNE(left.ll,
       ^~~~
       Cond
```
llvm/tools/pattern-gen/lib/Parser.cpp:577:8: warning: [readability-identifier-naming]

invalid case style for variable 'result'
```
  auto result = build.CreateSelect(cond, valTrue.ll, valFalse.ll);
       ^~~~~~
       Result
```
llvm/tools/pattern-gen/lib/Parser.cpp:581:7: warning: [readability-identifier-naming]

invalid case style for function 'gen_ternary'
```
Value gen_ternary(TokenStream &ts, llvm::Function *func,
      ^~~~~~~~~~~
      genTernary
```

llvm/tools/pattern-gen/lib/Parser.cpp:581:32: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

Value gen_ternary(TokenStream &ts, llvm::Function *func,
                               ^~
                               Ts

llvm/tools/pattern-gen/lib/Parser.cpp:581:52: warning: [readability-identifier-naming]

invalid case style for parameter 'func'

Value gen_ternary(TokenStream &ts, llvm::Function *func,
                                                   ^~~~
                                                   Func

llvm/tools/pattern-gen/lib/Parser.cpp:582:38: warning: [readability-identifier-naming]

invalid case style for parameter 'build'

                  llvm::IRBuilder<> &build, TokenType op, Value left,
                                     ^~~~~
                                     Build

llvm/tools/pattern-gen/lib/Parser.cpp:582:55: warning: [readability-identifier-naming]

invalid case style for parameter 'op'

                  llvm::IRBuilder<> &build, TokenType op, Value left,
                                                      ^~
                                                      Op

llvm/tools/pattern-gen/lib/Parser.cpp:582:65: warning: [readability-identifier-naming]

invalid case style for parameter 'left'

                  llvm::IRBuilder<> &build, TokenType op, Value left,
                                                                ^~~~
                                                                Left

llvm/tools/pattern-gen/lib/Parser.cpp:583:25: warning: [readability-identifier-naming]

invalid case style for parameter 'right'
```
                  Value right) {
                        ^~~~~
                        Right
```
llvm/tools/pattern-gen/lib/Parser.cpp:586:9: warning: [readability-identifier-naming]

invalid case style for variable 'ctx'
```
  auto &ctx = func->getContext();
        ^~~
        Ctx
```

llvm/tools/pattern-gen/lib/Parser.cpp:588:21: warning: [readability-identifier-naming]

invalid case style for variable 'blockTrue'

  llvm::BasicBlock *blockTrue = llvm::BasicBlock::Create(ctx, "true", func);
                    ^~~~~~~~~
                    BlockTrue

llvm/tools/pattern-gen/lib/Parser.cpp:589:21: warning: [readability-identifier-naming]

invalid case style for variable 'blockFalse'

  llvm::BasicBlock *blockFalse = llvm::BasicBlock::Create(ctx, "false", func);
                    ^~~~~~~~~~
                    BlockFalse

llvm/tools/pattern-gen/lib/Parser.cpp:590:21: warning: [readability-identifier-naming]

invalid case style for variable 'blockTerm'

  llvm::BasicBlock *blockTerm = llvm::BasicBlock::Create(ctx, "select", func);
                    ^~~~~~~~~
                    BlockTerm

llvm/tools/pattern-gen/lib/Parser.cpp:594:8: warning: [readability-identifier-naming]

invalid case style for variable 'cond'
```
  auto cond = build.CreateICmpNE(left.ll,
       ^~~~
       Cond
```
llvm/tools/pattern-gen/lib/Parser.cpp:599:8: warning: [readability-identifier-naming]

invalid case style for variable 'valTrue'
```
  auto valTrue = ParseExpression(ts, func, build);
       ^~~~~~~
       ValTrue
```
llvm/tools/pattern-gen/lib/Parser.cpp:605:8: warning: [readability-identifier-naming]

invalid case style for variable 'valFalse'
```
  auto valFalse = ParseExpression(ts, func, build);
       ^~~~~~~~
       ValFalse
```
llvm/tools/pattern-gen/lib/Parser.cpp:626:8: warning: [readability-identifier-naming]

invalid case style for variable 'retval'
```
  auto retval = build.CreatePHI(valTrue.ll->getType(), 2);
       ^~~~~~
       Retval
```
llvm/tools/pattern-gen/lib/Parser.cpp:634:7: warning: [readability-identifier-naming]

invalid case style for function 'gen_logical'
```
Value gen_logical(TokenStream &ts, llvm::Function *func,
      ^~~~~~~~~~~
      genLogical
```

llvm/tools/pattern-gen/lib/Parser.cpp:634:32: warning: [readability-identifier-naming]

invalid case style for parameter 'ts'

Value gen_logical(TokenStream &ts, llvm::Function *func,
                               ^~
                               Ts

llvm/tools/pattern-gen/lib/Parser.cpp:634:52: warning: [readability-identifier-naming]

invalid case style for parameter 'func'

Value gen_logical(TokenStream &ts, llvm::Function *func,
                                                   ^~~~
                                                   Func

llvm/tools/pattern-gen/lib/Parser.cpp:635:38: warning: [readability-identifier-naming]

invalid case style for parameter 'build'

                  llvm::IRBuilder<> &build, TokenType op, Value left,
                                     ^~~~~
                                     Build

llvm/tools/pattern-gen/lib/Parser.cpp:635:55: warning: [readability-identifier-naming]

invalid case style for parameter 'op'

                  llvm::IRBuilder<> &build, TokenType op, Value left,
                                                      ^~
                                                      Op

llvm/tools/pattern-gen/lib/Parser.cpp:635:65: warning: [readability-identifier-naming]

invalid case style for parameter 'left'

                  llvm::IRBuilder<> &build, TokenType op, Value left,
                                                                ^~~~
                                                                Left

llvm/tools/pattern-gen/lib/Parser.cpp:636:25: warning: [readability-identifier-naming]

invalid case style for parameter 'right'
```
                  Value right) {
                        ^~~~~
                        Right
```
llvm/tools/pattern-gen/lib/Parser.cpp:638:3: warning: [llvm-qualified-auto]

'const auto i1' can be declared as 'auto *const i1'
```
  const auto i1 = llvm::Type::getInt1Ty(func->getContext());
  ^~~~~~~~~~~
  auto *const 
```
llvm/tools/pattern-gen/lib/Parser.cpp:638:14: warning: [readability-identifier-naming]

invalid case style for variable 'i1'
```
  const auto i1 = llvm::Type::getInt1Ty(func->getContext());
             ^~
             I1
```
llvm/tools/pattern-gen/lib/Parser.cpp:640:9: warning: [readability-identifier-naming]

invalid case style for variable 'ctx'
```
  auto &ctx = func->getContext();
        ^~~
        Ctx
```
llvm/tools/pattern-gen/lib/Parser.cpp:641:21: warning: [readability-identifier-naming]

invalid case style for variable 'blockPre'
```
  llvm::BasicBlock *blockPre = build.GetInsertBlock();
                    ^~~~~~~~
                    BlockPre
```
llvm/tools/pattern-gen/lib/Parser.cpp:642:21: warning: [readability-identifier-naming]

invalid case style for variable 'blockEvalRHS'
```
  llvm::BasicBlock *blockEvalRHS =
                    ^~~~~~~~~~~~
                    BlockEvalRhs
```

llvm/tools/pattern-gen/lib/Parser.cpp:644:21: warning: [readability-identifier-naming]

invalid case style for variable 'blockPost'

  llvm::BasicBlock *blockPost = llvm::BasicBlock::Create(ctx, "logPost", func);
                    ^~~~~~~~~
                    BlockPost

llvm/tools/pattern-gen/lib/Parser.cpp:646:21: warning: [readability-identifier-naming]

invalid case style for variable 'trueBl'
```
  llvm::BasicBlock *trueBl = blockEvalRHS;
                    ^~~~~~
                    TrueBl
```
llvm/tools/pattern-gen/lib/Parser.cpp:647:21: warning: [readability-identifier-naming]

invalid case style for variable 'falseBl'
```
  llvm::BasicBlock *falseBl = blockPost;
                    ^~~~~~~
                    FalseBl
```
llvm/tools/pattern-gen/lib/Parser.cpp:660:8: warning: [readability-identifier-naming]

invalid case style for variable 'valRight'
```
  auto valRight = ParseExpression(ts, func, build);
       ^~~~~~~~
       ValRight
```

Have any feedback or feature suggestions? Share it here.

llvm/tools/pattern-gen/lib/Parser.cpp

core_descs/SelectTests.core_desc

mathis-s added 4 commits March 2, 2025 14:29

re-implemented select, added tests

f42ecd7

Add RUN command to test file

625e7d9

fix

a448ab8

update ADDN test

31659ae

PhilippvK approved these changes Mar 5, 2025

View reviewed changes

llvm/tools/pattern-gen/lib/Parser.cpp Show resolved Hide resolved

core_descs/SelectTests.core_desc Show resolved Hide resolved

fix instruction formats

14f232f

PhilippvK merged commit 7170b2d into llvm-19.1.0 Mar 6, 2025
6 checks passed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Re-implemented bitslice/sext/zext #52

Re-implemented bitslice/sext/zext #52

Uh oh!

mathis-s commented Mar 5, 2025

Uh oh!

github-actions bot commented Mar 5, 2025

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Re-implemented bitslice/sext/zext #52

Re-implemented bitslice/sext/zext #52

Uh oh!

Conversation

mathis-s commented Mar 5, 2025

Uh oh!

github-actions bot commented Mar 5, 2025

Cpp-Linter Report ⚠️

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants