This reverts commit 55c03f8

Incrementally design out support for try/catch and relationship
with calls. This introduces an exception information type, which
is will be returned somehow by throwing calls.

Silly mistake introduced in previous commit.

This is going to be used to raise `cir.call`s to `std::find(...)` into
`cir.std.find`.

Also implement lowering back to `std::call` before lowering to LLVM.

…lvm#353)

This PR fixes a global vars lowering with a funciton ptr field.
Previously, the next code caused fail in the `foo` lowering:
```
static void myfun(int a) {}

static struct {
    void (*func)(int flag);
} const Handlers[] = {
    {myfun}, {myfun}, {myfun}
};

void foo(int i, int flag) {
    Handlers[i].func(flag);
}
```

…ents.

Before this fix conversion of flat offset to GlobalView indices could
crash or compute invalid result.

This is the first part of implementing vector types and vector
operations in ClangIR, issue llvm#284. This is enough to compile this test
program. I haven't tried to do anything beyond that yet.
```
typedef int int4 __attribute__((vector_size(16)));
int main(int argc, char** argv) {
  int4 a = { 1, argc, argc + 1, 4 };
  int4 b = { 5, argc + 2, argc + 3, 8 };
  int4 c = a + b;
  return c[1];
}
```

This change includes:

* Fixed-sized vector types which are parameterized on the element type
and the number of elements. For example, `!cir.vector<s32i x 4>`. (No
scalable vector types yet; those will come later.)

* New operation `cir.vec` which creates an object of a vector type with
the given operands.

* New operation `cir.vec_elem` which extracts an element from a vector.
(The array subscript operation doesn't work here because the result is
an rvalue, not an lvalue.)

* Basic binary arithmetic operations on vector types, though only
addition has been tested.

There are no unary operators, comparison operators, casts, or shuffle
operations yet. Those will all come later.

…vm#356)

This PR adds a support for the multi-block case statements.
Previously, the code example below caused crash in cir verification

Lowering to the `llvm` dialect is pretty straightforward: the same logic
as before is applied to all the region's blocks with no successors, i.e.
we no longer think a case/default region contains only one block.

The `CodeGen` part is a little bit tricky. Previously, any sub-statement
of `case` or`default`, that was not any of them (i.e. neither `case` nor
`default`) was processed with an insertion guard, meaning that the next
sub-statement in the same clause was inserted again in the same block as
the first one. It would be fine, once sub-statement didn't generate any
blocks as well.

For instance,
```
void foo(int a) {
  switch (a)
  {
  case 3:
    return;
    break;
  }
}
```
The `return` statement actually emit a new block after, where the
unreachable code with `break` should be inserted in. That's why we also
need to update `lastCaseBlock` while generating `cir.switch`

This is quite frequent bug in `llvm-test-suite`

This contains just the skeleton, but the idea is that this pass is
going to contain transformations done on top CIR generated by the
C/C++ idiom recognizer.

Specify proper target triples to prevent issues on both Windows and MacOS
regarding non-implemented ABI bits.

Only a skeleton for incremental work.

Initial step into modeling iterators in CIR.

Right now it only looks at the member functions with .begin/.end function
calls, it does not look at the iterator type, has no notion of forward/reverse
iterators, nor filters based on the container types - those improvements will
come next.

…#355)

Before this fix attached test case has been failing due to type mismatch
(signed vs unsigned).

Tiny PR, support `-std=gnu89` option
This is quite frequent bug in `llvm-test-suite`

This PR "adds" the support of extern vars in function body. Actually, I
just erased an assert. Any reason it was there?
```
int foo() {
    extern int optind;
    return optind;
}
```

This is quite frequent bug in `llvm-test-suite`

This PR adds `cir.stack_save` and `cir.stack_restore` operations.

…m#357)

This PR fixes lowering of the next code:
```
void foo(int x, int y) {
    switch (x) {
        case 0:
            if (y)
                break;
            break;
    }
}
```
i.e. when some sub statement contains `break` as well. Previously, we
did this trick for `loop`: process nested `break`/`continue` statements
while `LoopOp` lowering if they don't belong to another `LoopOp` or
`SwitchOp`. This is why there is some refactoring here as well, but the
idea is stiil the same: we need to process nested operations and emit
branches to the proper blocks.

This is quite frequent bug in `llvm-test-suite`

This is how both libc++ and libstdc++ implement iterator in std::array, stick
to those use cases for now. We could add other variations in the future if there
are others around.

- Check whether container is part of std, add a fixed list of
available containers (for now only std::array)
- Add a getRawDecl method to ASTRecordDeclInterface
- Testcases

This was a bit half backed, give it some love.

Inspired by similar work in libc++, pointed to me by Louis Dionne
and Nikolas Klauser.

This is initial, very conservative and not generalized yet: works
for `char`s within a specific version of `std::find`.

This reverts commit bbaa147.

`ScopeOp` may end with `ReturnOp` instead of `YieldOp`, that is not
expected now. This PR fix this.
The reduced example is:
```
int foo() {
    {
        return 0;
    }
}
```
This is quite frequent bug in `llvm-test-suite`

One more step towards variable length array support.
This PR adds one more helper for the `alloca` instruction and re-use the
existing ones.

The reason is the following: right now there are two possible ways to
insert alloca: either to a function entry block or to the given block
after all the existing alloca instructions. But for VLA support we need
to insert alloca anywhere, right after an array's size becomes known.
Thus, we add one more parameter with the default value - insertion
point.

Also, we don't want copy-paste the code, and reuse the existing helpers,
but it may be a little bit confusing to read.

This PR adds `cir.ternary` lowering. There are two approaches to lower
`cir.ternary` imo:
1. Use `scf.if` op.
2. Use `cf.cond_br` op.

I choose `scf.if` because `scf.if` + canonicalization produces
`arith.select` whereas `cf.cond_br` requires scf lifting. In many ways
`scf.if` is more high-level and closer to `cir.ternary`.

A separate `cir.yield` lowering is required since we cannot directly
replace `cir.yield` in the ternary op lowering -- the yield operands may
still be illegal and doing so produces `builtin.unrealized_cast` ops. I
couldn't figured out a way to solve this issue without adding a separate
lowering pattern. Please let me know if you know a way to solve this
issue.

This PR fixes the next case
```
typedef struct { } A;

A create() { A a; return a; }

void foo() {
    A a;
    a = create();
}
```
i.e. when a struct  is assigned to a function call result

…vmgh-352) (llvm#363)

The error manifested in code like
```
int a[16];
int *const p = a;

void foo() {
  p[0];
}
```
It's one the most frequent errors in current llvm-test-suite.

I've added the test to globals.cir which is currently XFAILed, I think
@gitoleg will fix it soon.

Co-authored-by: Bruno Cardoso Lopes <bcardosolopes@users.noreply.github.com>

This PR addresses llvm#248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.

Currently, codegen of lvalue comma expression would crash:

```cpp
int &foo1();
int &foo2();

void c1() {
    int &x = (foo1(), foo2());  // CRASH
}
```

This simple patch fixes this issue.

This PR addresses llvm#90. It introduces a new type constraint `CIR_AnyType`
which allows CIR types and MLIR floating-point types. Present `AnyType`
constraints are replaced with the new `CIR_AnyType` constraint.

Arrays can be first declared without a known bound, and then defined
with a known bound. For example:

```cpp
extern int data[];

int test() { return data[1]; }

int data[3] {1, 2, 3};
```

Currently `clangir` crashes on generating CIR for this case. This is due
to the type of the `data` definition being different from its
declaration. This patch adds support for such a case.

…vm#381)

Breaks the pass into smaller more manageable rewrites.

… the files (llvm#390)

Fixes llvm#345

…IdiomRecognizer. (llvm#389)

Some tests started failing under `-DLLVM_USE_SANITIZER=Address` due to
trivial use-after-free errors.

Like SCF's `scf.condition`, the `cir.condition` simplifies codegen of
loop conditions by removing the need of a contitional branch. It takes a
single boolean operand which, if true, executes the body region,
otherwise exits the loop. This also simplifies lowering and the dialect
it self.

A new constraint is now enforced on `cir.loops`: the condition region
must terminate with a `cir.condition` operation.

A few tests were removed as they became redundant, and others where
simplified.

The merge-cleanups pass no longer simplifies compile-time constant
conditions, as the condition body terminator is no longer allowed to be
terminated with a `cir.yield`. To circumvent this, a proper folder
should be implemented to fold constant conditions, but this was left as
future work.

Co-authored-by: Bruno Cardoso Lopes <bcardosolopes@users.noreply.github.com>

Once the LexicalScope goes out of scope, its cleanup process will also
check if a return was set to be yielded, and, if so, generate the yield
with the respective value.

ghstack-source-id: 9305d2ba5631840937721755358a774dc9e08b90
Pull Request resolved: llvm#312

Instead of returning a boolean indicating whether the statement was
handled, returns the ReturnExpr of the statement if there is one. It
also adds some extra bookkeeping to ensure that the result is returned
when needed. This allows for better support of GCC's `ExprStmt`
extension.

The logical result was not used: it was handled but it would never fail.
Any errors within builders should likely be handled with asserts and
unreachables since they imply a programmer's error in the code.

ghstack-source-id: 2319cf3f12e56374a52aaafa4304e74de3ee6453
Pull Request resolved: llvm#313

Adds support for GCC statement expressions return values as well as
StmtExpr LValue emissions.

To simplify the lowering process, the scope return value is not used.
Instead, a temporary allocation is created on the parent scope where the
return value is stored. For classes, a second scope is created around
this temporary allocation to ensure any destructors are called.

This does not implement the full semantics of statement expressions.

ghstack-source-id: 64e03fc3df45975590ddbcab44959c2b49601101
Pull Request resolved: llvm#314

….scope

Incremental work, test coming soon. This code path isn't exercised just yet.

This will be used for any calls happening inside try regions.

More refactoring. For now it's incremental work, still some mileage to cover
before I can introduce a testcase. The current implementation mimics cir.call,
pieces are going to change in following commits.

The next step for inline assembly. Sorry, maybe it looks too big on the
first glance. And it's kind of hard to extract something well-grained
from the code and introduce it as a separate PR, but I try.

Actually there is nothing really interesting done here, and the next
will (I hope :) ) simplify your review process.

1) In this PR we introduce operand's constraints and the task is to
collect them (and maybe transform a little)
2) There are two big functions copy-pasted from the traditional
`Codegen` and I doubt they need to be reviewed.
3) We still don't do anything CIR-specific. Basically, we just work with
strings in the same way like traditional `Codegen` does.
4) We just iterate over the input and output operands and collect the
constraints
5) We still follow to the traditional `CodeGen` and don't do anything
new, except a separate function that collects constraints infos in the
very beginning of the `buildStmt`.

Also, I renamed `AsmDialect` to `AsmFlavor` as you asked in llvm#326

This PR fixes CIR lowering for the next case.

```
void foo() {
    struct {
        int a;
        int b;
    } a[1] = {{0,1}};
}
```
Note, we don't create attribute here and lower such const arrays as
values.

When introducing attribute `#cir.int`, the constant type verification is
not updated. If a `cir.const` operation produces an integral constant
from a `#cir.int` attribute, the integer's type is not verified:

```mlir
%1 = cir.const(#cir.int<0> : !cir.int<s, 8>) : !cir.int<u, 8>
// Not verified: !cir.int<s, 8> differs from !cir.int<u, 8>
```

The corresponding test is also wrong but fail to be detected.

This patch fixes this issue.

This is part 2 of implementing vector types and vector operations in
ClangIR, issue llvm#284.

Create new operation `cir.vec.insert`, which changes one element of an
existing vector object and returns the modified vector object. The input
and output vectors are prvalues; this operation does not touch memory.
The assembly format and the order of the arguments match that of
llvm.insertelement in the LLVM dialect, since the operations have
identical semantics.

Implement vector element lvalues in class `LValue`, adding member
functions `getVectorAddress()`, `getVectorPointer()`, `getVectorIdx()`,
and `MakeVectorElt(...)`.

The assembly format for operation `cir.vec.extract` was changed to match
that of llvm.extractelement in the LLVM dialect, since the operations
have identical semantics.

These two features, `cir.vec.insert` and vector element lvalues, are
used to implement `v[n] = e`, where `v` is a vector. This is a little
tricky, because `v[n]` isn't really an lvalue, as its address cannot be
taken. The only place it can be used as an lvalue is on the left-hand
side of an assignment.

Implement unary operators on vector objects (except for logical not on a
vector mask, which will be covered in a future commit for boolean
vectors). The code for lowering cir.unary for all types, in
`CIRUnaryOpLowering::matchAndRewrite`, was largely rewritten. Support
for unary `+` on non-vector pointer types was added. (It was already
supported and tested in AST->ClangIR CodeGen, but was missing from
ClangIR->LLVM Dialect lowering.)

Add tests for all binary vector arithmetic operations other than
relational operators and shift operators. There were all working after
the previous vector types commit, but only addition had beet tested at
the time.

Co-authored-by: Bruno Cardoso Lopes <bcardosolopes@users.noreply.github.com>

Detaches the representation of the C/C++ `continue` statement into a
separate operation. This simplifies mostly lowering and verifications
related to `continue` statements, as well as the definition and lowering
of the `cir.yield` operation.

A few checks regarding region terminators were also removed from the
lowering stage, since they are already enforced by MLIR.

ghstack-source-id: 1810a48ada88fe7ef5638b0758a2298d9cfbdb8b
Pull Request resolved: llvm#394

Same rationale as `cir.continue`, it detaches the representation of the
C/C++ `break` statement into a separate operation. This simplifies
lowering and verifications related to `break` statements, as well as the
definition and lowering of the `cir.yield` operation.

ghstack-source-id: 929cf96c3abe51d717c2fa6ca9e0073e42e770c6
Pull Request resolved: llvm#395

This changes the `cir.await` operation to expect a `cir.condition` as
the terminator for the ready region. This simplifies the `cir.await`
while also simplifying the `cir.yield`. If `cir.condition` holds a
true value, then the `cir.await` will continue the coroutine, otherwise,
it will suspend its execution.

The `cir.condition` op was also updated to allow `cir.await` as its
parent operation.

ghstack-source-id: 1ebeb2cfbdeff6f289936d16354cba534e093ea7
Pull Request resolved: llvm#396

Instead of having a `cir.yield fallthrough` operation, the default
branching behavior of the parent operation is denoted by `cir.yield`.
In other words, a `cir.yield` operation in a switch case region
represents the default branching behavior of the switch operation, which
is a fallthrough.

The `cir.yield` operation now represents the default branching behavior
of the parent operation's region. For example, in a if-else region, a
`cir.yield` operation represents a branch to the exit block.

ghstack-source-id: 713c457dfb2228fbdf63ba72dd6396665512bb9d
Pull Request resolved: llvm#397

…tcase

- Add cir.try_call parsing.
- Add block destinations and hookup exception info type.
- Properly implement interface methods.

Printer is still missing, but coming next.

After some discussions with @sitio-couto, it might be better if we use a
simplified version that doesn't take the labels into account just yet.
`cir.try_call` should have the same semantics as `cir.break`, in the sense that
it needs further expansion when getting rid of structured control flow. Early
lowering here would complicate CIR generated code and make it harder to
analyse. Further CIR to CIR passes will properly expand this at some point
prior to LLVM lowering.

We can now handle more of EHScope::Catch and lay out the skeleton for CIR's
version of that, adding tons of asserts for cases not currently handled. As
part of this we're able to build the clause list as part of CatchOp based on
the handlers, and create allocation for the exception_info type.

In the next part (where we currently hit an assert) of this work, the CatchOp
will then get its regions populated.

Incremental steps into getting basic exceptions to work, not enough for a
testcase just yet.

Doesn't do a lot of things compared to LLVM traditional codegen, one
more step towards basic exception support. No testcase possible just yet.

- Add an extra CatchOp region to hold fallback (where EH usually resumes or
  rethrows as part of try/catch).
- Emit `cir.resume` on the fallback region.

Incremental step into the next assertion, still missing pieces before adding
the first testcase.

This commit supports the codegen of wide string literals, including
`wchar_t` string literals, `char16_t` string literals, and `char32_t`
string literals.

I'm not following the proposal in llvm#374. The clang frontend doesn't
record the literal string. It only records the encoded code units for
wide string literals. So I believe that a dedicated string attribute
with an encoding tag as described in llvm#374 may not be that helpful as I
thought.

This patch introduces initial support for:
```
pragma omp parallel
```

This patch doesn't add support for any of the `parallel` clauses,
including variable privatization; thus, all variables are handled as
shared.

This PR fixes issue llvm#285.

Adds an interface to generically handle lowering and analysis of loop
operations in CIR. It can also perform verification of invariants common
to all loop operations.

ghstack-source-id: 0e413b14ea063a2b0d75aeaca0af88e547c15277
Pull Request resolved: llvm#405

Leverages the new LoopOpInterface for lowering instead of the LoopOp
operation. This is a step towards removing the LoopOp operation.

ghstack-source-id: 28c1294833a12669d222a293de76609d2cf19148
Pull Request resolved: llvm#406

Creates a separate C/C++ operation for do-while loops, while keeping the
LoopOpInterface to generically handle loops. This simplifies the IR
generation and printing/parsing of do-while loops. It also allows us to
define it regions in the order that they are executed, which is useful
for the lifetime analysis.

ghstack-source-id: b4d9517197b8f82ae677dc2684101fe5762b21b7
Pull Request resolved: llvm#407

Creates a separate C/C++ operation for while loops, while keeping the
LoopOpInterface to generically handle loops. This simplifies the IR
generation and printing/parsing of while loops.

ghstack-source-id: 29a6d7530263a4f96dbe6ce3052875831126005d
Pull Request resolved: llvm#408

This patch completes the deprecation of the generic `cir.loop` operation
by adding a new `cir.for` operation and removing the `cir.loop` op. The
new representation removes some bloat and places the regions in order of
execution.

ghstack-source-id: 886e0dacc632e5809015e2212810d690ef3ec294
Pull Request resolved: llvm#409

…rations

More machinery for exceptions.

This time around we finally emit a cir.catch and fix the order of emitting
operations. This allows a testcase to be added. I also added `CatchParamOp`,
which fetches the arguments for the clauses from the !cir.eh_info object.

Work coming next:
- Dtors.
- Use cir.try instead of cir.scope.
- Eesume.
- Documentation.`

ghstack-source-id: 855519648a4bf2dced501f96e6de1b9b164d85ad
Pull Request resolved: llvm#424

This is currently missing and Debug builds are failing without it.

… dep

ghstack-source-id: 0706d6bb81b5b8eefb04146719b4443aedb29ab1
Pull Request resolved: llvm#427

One more step towards completing try/catch.

…rface

This is prep work for introducing cir.try_call inside cir.try scopes.

One more incremental step towards try/catch: properly use cir.try_call instead
of regular cir.call when within a cir.try region.

)

This patch adds a new `volatile` tag to the following operations to
distinguish volatile loads and stores from normal loads and stores:

- `cir.load`
- `cir.store`
- `cir.get_bitfield`
- `cir.set_bitfield`

Besides, this patch also updates the CodeGen and LLVMIR lowering code to
start emitting CIR and LLVMIR operations with volatile flag.

This is part 3 of implementing vector types and vector operations in
ClangIR, issue llvm#284.

Create new operation `cir.vec.cmp` which implements the relational
comparison operators (`== != < > <= >=`) on vector types. A new
operation was created rather than reusing `cir.cmp` because the result
is a vector of a signed intergral type, not a `bool`.

Add CodeGen and Lowering tests for vector comparisons.

Fix the floating-point comparison predicate when lowering to LLVM. To
handle NaN values correctly, the comparisons need to be ordered rather
than unordered. (Except for `!=`, which needs to be unordered.) For
example, "ueq" was changed to "oeq".

Compilation of the following test
```
void foo6(A* a1) {
  A a2 = (*a1);
}
```
fails with.
```
NYI
UNREACHABLE executed at /home/huawei/cir/repo/llvm-project/clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp:175!
```
Commit adds required visitor and fixes the issue.

In the original codegen a new type is created for the base class, while
in CIR we were rewriting the type being processed (due tp misused
pointers). This PR fix this, and also makes CIR codegen even with the
original one.

This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in llvm#367 llvm#346 llvm#340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.

Support \_\_extension\_\_ keyword in CIRGen

Support for BoolAttr in isNullValue

This PR adds support for section("$name") attribute

Support missing zero initialization of Bools