Incremental step: we need the full try/catch to test `cir.try_call`, so testing
coming next with the other necessary operations.

…nflightOp

…and `cir.eh.inflight_exception`

- Fix parser problems that were preventing testing and fix additional lowering missing for `cir.try_call`.
- Add lowering from scratch for `cir.eh.inflight_exception`.

End-to-end requires full exception support (still more lowering TBD to get
there).

… unified AS (llvm#682)

`TargetCodeGenInfo::getASTAllocaAddressSpace` is a bad design because it
requires the targets return `LangAS`, which enforce the targets to
consider which languages could be their upstream and unnecessarily
complicate the target info. Unified AS in CIR is a better abstraction
level for this kind of target info.

Apart from that, the languages also has some requirements on the result
address space of alloca.

```cpp
void func() {
  int x;
  // Here, the AS of pointer `&x` is the alloca AS defined by the language.
}
```

When we have inconsistency between the alloca AS defined by the language
and the one from target info, we have to perform `addrspacecast` from
the target one to the language one.

This PR includes
* New method `CGM.getLangTempAllocaAddressSpace` which explicitly
specifies the alloca address space defined by languages. It replaces the
vague `LangAS::Default` in the AS comparisons from OG CodeGen.
* Replace `getASTAllocaAddressSpace` with `getCIRAllocaAddressSpace`,
which returns CIR unified AS.
* Also use `getCIRAllocaAddressSpace` as the result address space of
`buildAlloca`.
* Fix the lowering of `cir.alloca` operation to be address-space-aware.

We don't perform any `addrspacecast` in this PR, i.e. all the related
code paths still remain NYI and it's fine. That's because we don't even
have a `(language, target)` pair holding the inconsistency.

After these changes, in the previous OpenCL testcases we will see all
the alloca pointers turning into private AS, without any
`addrspacecast`.

…ering bugs. (llvm#756)

In this pr, I lowering cir.do to scf.while, fix cir.while nested loop
bugs and add test cases.

This PR adds CIRGen for scalar `co_yield` expressions.

This PR adds CIRGen support for the `__builtin_bit_cast` builtin. No new
operations are added so the LLVM IR lowering is also added
automatically.

…irect and Extend (llvm#763)

This NFCI PR enhances the SPIR-V *CIRGen* ABI with Direct and Extend in
both argument and return value, because some future test cases requires
it.

* kernel argument metadata needs arguments of promotable integer types
* builtin functions like `get_global_id` returns `si64`, rather than
void for all OpenCL kernels

Given that CallConvLowering will replace these bits and other targets is
already doing the same, I think it's safe to enable it now.

…nt ops (llvm#768)

Soon I would like to submit a patch emitting OpenCL module metadata in
LowerToLLVM path, which requires to attach the metadata to LLVM module
when `amendOperaion` is called for MLIR module op. This PR refactors the
method to a dispatcher to make the future changes cleaner.

Similar to llvm#705, this PR implements the remaining
`genKernelArgMetadata()` logic.

The attribute `cir.cl.kernel_arg_metadata` is also intentionally placed
in the `cir.func`'s `extra_attrs` rather than `cir.func`'s standard
`arg_attrs` list. Also, the metadata is stored by `Array` with proper
verification on it. See the tablegen doc string for details.

This is in order to
* keep it side-by-side with `cl.kernel_metadata`.
* still emit metadata when kernel has an *empty* arg list (see the test
`kernel-arg-meatadata.cl`).
* avoid horrors of repeating the long name `cir.cl.kernel_arg_metadata`
for `numArgs` times.

Because clangir doesn't support OpenCL built-in types and the `half`
floating point type yet, their changes and test cases are not included.
Corresponding missing feature flag is added.

…lvm#760)

This PR simply adds the calling convention attribute to FuncOp with LLVM
Lowering support.

The overall approach follows `GlobalLinkageKind`: Extend the ODS,
parser, printer and lowering pass. When the call conv is C call conv,
it's omitted in the output assembly.

---------

Co-authored-by: Bruno Cardoso Lopes <[email protected]>

…values (llvm#753)

This commit makes the changes as following.

1. Enable array type GlobalOp lowering with initial values

2. Add error message when array size is not equal to initial string
value size
       E.g. char big_string[10] = "abc";

…vm#769)

There are two sources for the target allocation address space: one from
`TargetCIRGenInfo::getCIRAllocaAddressSpace()` and another from
`targetDataLayout.getAllocaMemorySpace()`. Since both are provided by
the specific target, they should be consistent. This PR adds a check to
ensure this consistency and avoid potential errors.

The ctor of `CIRAllocaLowering` pattern is updated to pass the data
layout in.

…e one in dialect (llvm#772)

This PR remove the header `CIR/CodeGen/CallingConv.h` and migrates all
`::cir::CallingConv` stuff to `::mlir::cir::CallingConv` in
`CIRGenTypes` and `CIRGenFunctionInfo`.

In TargetLowering library, LowerTypes and LowerFunctionInfo basically
have the same clangCallConvToLLVMCallConv stuff. The CC there is the
LLVM one. But those changes are not included because of the potential
conflicts. We can still easily switch to the dialect when it's needed.

This PR adds OpenCL C language case to the enum
`mlir::cir::SourceLanguage`, and maps `opts.OpenCL &&
!opts.OpenCLCPlusPlus` to it.

This PR introduce cir simplification pass. The idea is to have a pass
for the redundant operations removal/update.

Right now two pattern implemented, both related to the redundant `bool`
operations.
First pattern removes redundant casts from `bool` to `int` and back that
for some reasons appear in the code.
Second pattern removes sequential unary not operations (`!!`) .

For example, the code from the test is expanded from the simple check
that is common for C code:

```
#define CHECK_PTR(ptr)  \
  do {                   \
    if (__builtin_expect((!!((ptr) == 0)), 0))\
      return -42; \
  } while(0)
```

I mark this PR as a draft for the following reasons:
1) I have no idea if it's useful for the community
2) There is a test fail - unfortunately current pattern rewriter run DCE
underneath the hood and looks like we can't workaround it.
It's enough just to add an operation to the list - in this case
`UnaryOp` - and call `applyOpPatternsAndFold`. I could rewrite a test a
little in order to make everything non dead or implement a simple fix
point algorithm for the particular task (I would do the former).

This PR adds support for complex cast operations. It adds the following
new cast kind variants to the `cir.cast` operation:

  - `float_to_complex`,
  - `int_to_complex`,
  - `float_complex_to_real`,
  - `int_complex_to_real`,
  - `float_complex_to_bool`,
  - `int_complex_to_bool`,
  - `float_complex`,
  - `float_complex_to_int_complex`,
  - `int_complex`, and
  - `int_complex_to_float_complex`.

CIRGen and LLVM IR support for these new cast variants are also
included.

…arget (llvm#773)

Similar to llvm#767, this PR emit the module level OpenCL version metadata
following the OG CodeGen skeleton.

We use a full qualified `cir.cl.version` attribute on the module op to
store the info in CIR.

This PR adds folders for `cir.complex.create`, `cir.complex.real`, and
`cir.complex.imag`.

This PR adds a new attribute `#cir.complex` that represents a constant
complex value. Besides, the CIR dialect does not have a constant
materializer yet; this PR adds it.

Address llvm#726 .

…all conv (llvm#778)

This PR follows OG CodeGen to use SPIR ABI info whatever the target is
when analysing the function info of SPIR-V kernels (identified by its
calling convention).

For example, when compiling OpenCL kernels to x86-64 target, the kernel
should still use SPIR-V's ABIInfo.

As we haven't implemented SPIR-V ABI handling for complex constructs,
there should be no functional changes. There is a test for this logic in
OG CodeGen:
`clang/test/CodeGenOpenCL/kernels-have-spir-cc-by-default.cl`. It mainly
involves structs, which is beyond the progress of CIR ABI stuff.

This PR adds the CIR address space attribute to GlobalOp and starts to
resolve the missing feature flag `addressSpaceInGlobalVar`.

The same asm format in pointer type is used:

```
cir.global external addrspace(offload_global) @addrspace1 = #cir.int<1> : !s32i
```

The parsing and printing helper is extracted into a common function to
be reused by both `GlobalOp` and `PointerType` with two custom format
proxy to it. That's because the signature of ODS generated method
differs from the one for PointerType.

Lowering to LLVM IR and CIRGen will come sequentially.

Incremental work: test is available in the followup commit.

This PR adds the counterparts of methods `SetFunctionAttributes`
`SetLLVMFunctionAttributes` from OG CodeGen, in order to set proper
calling conv for `cir.func` ops.

`spir-calling-conv.cl` is the dedicated test, while other OpenCL-related
tests are also updated. It removes previous workaround of incorrect
calling conv and better synchronizes with the original tests. (These
changes are not musts).

…iles (llvm#781)

This PR refactors OpenCL-specific logic that is rather independent from
CIRGen and dialect definition into two new implementation files:
`CIRGenOpenCL.cpp` and `CIROpenCLAttrs.cpp`.

There will also be a `CIRGenOpenCLRuntime.cpp` in the future as the
counterpart of `CGOpenCLRuntime.cpp` from OG CodeGen. But that's
basically a dedicated implementation file of a class `CGOpenCLRuntime`,
we should not bother it.

…pass pipeline

Unbreaks `ninja check-clang-extra-clang-tidy`

…ings

…#782)

This PR enables ClangIR pipeline for LLVM bitcode output when it's
specified properly, aligned with the behavior of text-form LLVM IR.

Some refactors about switch cases are also included to avoid too many
dups.

The LLVM lowering actually maps to the version without fast math, to add
support for fast math we need to set the proper LLVM attribute on each of those
operations.

…m#783)

This PR set a proper addrspace attribute for LLVM globals. For
simplicity, a temporary pointer type is created and consumed by our LLVM
type converter. The correct address space is then extracted from the
converted pointer type of LLVM.

This patch adds the necessary bits for unraveling struct arguments and
return values for the x86_64 calling convention.

… of std::initializer_list (llvm#764)

implement VisitCXXStdInitializerListExpr as similar as to
[OG](https://github.com/llvm/clangir/blob/7150a050c12119c27e9eb1547aa65f535e4bfbe9/clang/lib/CodeGen/CGExprAgg.cpp#L417):
In order to support this implementation, made some changes to get more
helper functions.
Also added some tests.

The generated LLVM code is most similar to OG's llvm code, 3 interesting
differences:
1.  CIR introduced scope, thus extra branch
2. OG' has comdat for _ZSt1fIiEvSt16initializer_listIT_E function, but
we haven't implemented FuncOP's comdat yet. I'll probably try to add it
in another PR, but it's not in the scope of this PR.
3. When defining initialized_list type, OG prefers generic type like
%"class.std::initializer_list" = type { ptr, ptr }, but CIR prefers
instantiated like "%"class.std::initializer_list<const char *>" = type {
ptr, ptr }"

This PR adds CIRGen and LLVMIR codegen for those not-yet-covered complex
casts, including explicit type cast expressions of complex types and
complex value promotion.

All type conversion expressions involving complex types should now
codegen.

…m#787)

This PR verifies `cir.get_global` has its result type correctly
annotated with address space of the referenced symbol. The documentation
is also updated to clarify this constraint.

`GlobalOp` is the main consideration. It's worth noting that if the
`cir.get_global` op references a function, we also (implicitly) checks
that its result pointer type has no address space attribute.

This PR sets proper address space when creating `cir.global` and
`cir.get_global`.

Different languages use different ways to encode the address space in
AST constructs (i.e. VarDecl *). OpenCL and SYCL use an address space
qualifier on the type of `VarDecl`, while CUDA uses separate AST
attributes like `CUDASharedAttr`. Similarily, some targets may want to
use special address space for global variables. So a per-language +
per-target hook is needed to provide this customization point. In the
LLVM CodeGen, it's the helper method `getGlobalVarAddressSpace` that
takes on the role.

For OpenCL C + SPIR-V combination, OpenCL C converts the address space
qualifier to corresponding LangAS, but SPIR-V does not require any
action.

This PR implements `global` qualifier in OpenCL C, but does not include
`constant` qualifier. Although the modified part works for `constant`,
CIRGen is not yet able to set constant attribute for global ops (there
is a TODO line).

Static variable decl and `local` qualifier work in a similar way and
come in later patches.

Unary decrement expression on floating point operands was lowered to
`fsub -1.0` by a typo. This PR fixes this bug.

…otected (llvm#776)

This PR add a new CIR attribute `mlir::cir::VisibilityAttr` to represent
CIR visibility. It will represent C/C++ visibility type `Default`,
`Hidden`, `Protected`.

The PR handles the parsing, printing of CIR visibility and also lower to
LLVM.

After this PR, there will be more PR's to migrate CIRGen properties that
are currently querying MLIR visibility(e.g. `sym_visibility`), to
instead query CIR visibility, and remove MLIR's visibility from printing
and parsing.

This PR adds CIRGen and LLVMIR lowering for unary increment and
decrement expressions of complex types.

Currently blocked by llvm#789 .

…d variables (llvm#792)

In OpenCL, `local`-qualified variables are implicitly considered as
static. In order to support it, this PR unblocks code paths related to
OpenCL static declarations in `CIRGenDecl.cpp`.

Following the approach of LLVM CodeGen, a new class
`CIRGenOpenCLRuntime` is added to handle the language hook of creating
`local`-qualified variables. The default behavior of this hook is quite
simple. It forwards the call to `CGF.buildStaticVarDecl`.

So in CIR, the OpenCL local memory representation is equivalent to the
one defined by SPIR-LLVM convention: a `cir.global` with
`addrspace(local)` and *without initializer*, which corresponds to LLVM
`undef` initializer. See check lines in test for more details.

A `static global`-qualified variable is also added in the test to
exercise the static code path itself.

This patch fixes a bunch of pending review comments in llvm#784:

 - Remove data layout attribute from address space testing
 - Remove incoherent comment
 - Rename abi_or_pref to abiOrPref
 - Make comments impersonal
 - Implement feature guard for ARM's CMSE secure call feature
 - Track volatile return times feature in CC lowering
 - Track missing features in the Itanium record builder
 - Remove incoherent fix me
 - Clarify comment regarding CIR record layout getter
 - Track missing cache for record layout getter
 - Remove unnecessary todo's

…m#722)

This PR adds the initial CIRGen support for pointer-to-member-functions.
It contains the following new types, attributes, and operations:

  - `!cir.method`, which represents the pointer-to-member-function type.
- `#cir.method`, which represents a literal pointer-to-member-function
value that points to ~~non-virtual~~ member functions.
- ~~`#cir.virtual_method`, which represents a literal
pointer-to-member-function value that points to virtual member
functions.~~
- ~~`cir.get_method_callee`~~ `cir.get_method`, which resolves a
pointer-to-member-function to a function pointer as the callee.

See the new test at `clang/test/CIR/CIRGen/pointer-to-member-func.cpp`
for how these new CIR stuff works to support
pointer-to-member-functions.

Achieve union's bitfields additionally.

This PR adds a new `cir.select` operation. This operation won't be
generated directly by CIRGen but it is useful during further CIR to CIR
transformations.

This PR addresses llvm#785 .

There is an implementation for inline variables processing at CIR. The
LIT test was taken from clang's cxx1z-inline-variables.cpp where the
same functionality is tested for Clang Code generation. The test can be
run as follows
```
bin/llvm-lit -v ../clang/test/CIR/CodeGen/cxx1z-inline-variables.cpp
```

Note: the pull request also contains a formatting change for two files:
- `clang/lib/CIR/Dialect/IR/CIRDataLayout.cpp`
- `clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/X86.cpp`

mixed signed and unsigned integer operator cause difference result when
index of array is negative

…lvm#800)

This PR refactors the LoweringPrepare pass and replaces various ternary
ops generated by LoweringPrepare with semantically equivalent select
ops.

llvm#799)

`__sync_fetch_and_add` currently doesn't support unsigned integers. 

The following code snippet, for example, raises an error:  
```
#include <stdint.h>

void foo(uint64_t x) {
  __sync_fetch_and_add(&x, 1);
}
```
The error can be traced down to this line `auto intType =
builder.getSIntNTy(cgf.getContext().getTypeSize(typ));` from
`clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp`.

…ry fp2fp operations (llvm#806)

This PR is the continuation and refinement of PR llvm#434 which is
originally authored by @philnik777 . Does not update it in-place since I
don't have commit access to Nikolas' repo.

This PR basically just rebases llvm#434 onto the latest `main`. I also
updated some naming used in the original PR to keep naming styles
consistent.

Co-authored-by: Nikolas Klauser <[email protected]>

…r try local allocas

Still missing CFG flattening and lowering, coming next.

…pushTemporaryCleanup

- Tackle a FIXME left in previous commit.
- Start turning missing cleanup features into actual NYI asserts.
- Make sure we run CleanupDeactivationScope properly and deactivate necessary cleanups.
- Add more verifications/asserts for overall state.

This is currently crashing on Linux only internally, but not on GitHub's CI,
disable it temporarily while we investigate.

This is a straightforward adaption of existing CodeGen logic. While I'm
here, move block comments inside their blocks, so that they look nicer.

…VM (llvm#810)

As title.
Add setAlignmentAttr for GlobalOps created from AST.
LLVM Lowering should have LLVM GlobalOp's alignment attribute inherited
from CIR::GlobalOp.

This PR is definitely needed to fix issue
llvm#801 (comment), but
the issue doesn't have alignment and comdat attribute for CIR Ops to
begin with, so I'll keep investigating and fix CIR problem in another
PR.

…y cast op (llvm#812)

There are two occurrences of `cir.cast(array_to_ptrdecay, ...)` that
drop address spaces unexpectedly for its result pointer type. This PR
fixes them with the source address space.

```mlir
// Before
%1 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr<!cir.array<!s32i x 32>, addrspace(offload_local)>), !cir.ptr<!s32i>
// After
%1 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr<!cir.array<!s32i x 32>, addrspace(offload_local)>), !cir.ptr<!s32i, addrspace(offload_local)>
```

As mentioned at
llvm#809 (comment) , this
PR adds more simplify transformations for select op:

- `cir.select if %0 then x else x` -> `x`
- `cir.select if %0 then #true else #false` -> `%0`
- `cir.select if %0 then #false else #true` -> `cir.unary not %0`

…p ops (llvm#818)

This PR makes simple lowering generate the result type lowering logic
and make it suitable for unary fp2int operations and binary fp2fp
operations.

…ization (llvm#820)

This PR adds initial support for temporary materialization of local
temporaries with trivial cleanups.

Materialization of global temporaries and local temporaries with
non-trivial cleanups is far more trickier that I initially thought and I
decide to submit this easy part first.

This is a straightforward adaption from CodeGen. I checked the uses of
the Delegating arg that's passed in various places, and it only appears
to be used by virtual inheritance, which should be handled by
llvm#624.

…on (llvm#813)

Currently some bitcasts would silently change the address space of
source pointer type, which hides some miscompilations of pointer type in
CIR.

llvm#812 is an example. The address space in result pointer type is dropped,
but the bitcast later keep the type consistency no matter what the
result type is. Such bitcast is commonly emitted in CodeGen.

CIR bitcasts are lowered to LLVM bitcasts, which also don't allow
mismatch between address spaces. This PR adds this verification.

We were previously printing the type alias for `struct S` as `!ty_22S22`
instead of just `!ty_S`. This was because our alias computation for a
StructType did the following:

    os << "ty_" << structType.getName()

`structType.getName()` is a `StringAttr`, and writing a `StringAttr` to
an output stream adds double quotes around the actual string [1][2].
These double quotes then get hex-encoded as 22 [3].

We can fix this by writing the actual string value instead. Aliases that
would end in a number will now receive a trailing underscore because of
MLIR's alias sanitization not allowing a trailing digit [4] (which
ironically didn't kick in even though our aliases were always previously
ending with a number, which might be a bug in the sanitization logic).
Aliases containing other special characters (e.g. `::`) will still be
escaped as before. In other words:

```
struct S {};
// before: !ty_22S22 = ...
// after:  !ty_S = ...

struct S1 {};
// before: !ty_22S122 = ...
// after:  !ty_S1_ = ...

struct std::string {};
// before: !ty_22std3A3Astring22
// after:  !ty_std3A3Astring
```

I'm not a big fan of the trailing underscore special-case, but I also
don't want to touch core MLIR logic, and I think the end result is still
nicer than before.

The tests were mechanically updated with the following command run
inside `clang/test/CIR`, and the same commands can be run to update the
tests for any in-flight patches. (These are for GNU sed; for macOS
change the `-i` to `-i ''`.)

find . -type f | xargs sed -i -E -e
's/ty_22([A-Za-z0-9_$]+[0-9])22/ty_\1_/g' -e
's/ty_22([A-Za-z0-9_$]+)22/ty_\1/g'

clang/test/CIR/CodeGen/stmtexpr-init.c needed an additional minor fix to
swap the expected order of two type aliases in the CIR output.
clang/test/CIR/CodeGen/coro-task.cpp needed some surgery because it was
searching for `22` to find the end of a type alias; I changed it to
search for the actual alias instead.

If you run into merge conflicts after this change, you can auto-resolve
them via

smeenai@715f061

[1]
https://github.com/llvm/llvm-project/blob/b3d2d5039b9b8aa10a86c593387f200b15c02aef/mlir/lib/IR/AsmPrinter.cpp#L2295
[2]
https://github.com/llvm/llvm-project/blob/b3d2d5039b9b8aa10a86c593387f200b15c02aef/mlir/lib/IR/AsmPrinter.cpp#L2763
[3]
https://github.com/llvm/llvm-project/blob/b3d2d5039b9b8aa10a86c593387f200b15c02aef/mlir/lib/IR/AsmPrinter.cpp#L1014
[4]
https://github.com/llvm/llvm-project/blob/b3d2d5039b9b8aa10a86c593387f200b15c02aef/mlir/lib/IR/AsmPrinter.cpp#L1154

This PR fixes the lowering for BrCond. 

Consider the following code snippet: 
```
#include <stdbool.h>

bool test() {
  bool x = false;
  if (x) 
    return x;
  return x;
} 
```
Emitting the CIR to `tmp.cir` using `-fclangir-mem2reg` produces the
following CIR (truncated):
```
!s32i = !cir.int<s, 32>
#fn_attr = #cir<extra({inline = #cir.inline<no>, nothrow = #cir.nothrow, optnone = #cir.optnone})>
module { cir.func no_proto  @test() -> !cir.bool extra(#fn_attr) {
    %0 = cir.const #cir.int<0> : !s32i 
    %1 = cir.cast(int_to_bool, %0 : !s32i), !cir.bool 
    cir.br ^bb1 
  ^bb1:  // pred: ^bb0
    cir.brcond %1 ^bb2, ^bb3 
  ^bb2:  // pred: ^bb1
    cir.return %1 : !cir.bool 
  ^bb3:  // pred: ^bb1
    cir.br ^bb4 
  ^bb4:  // pred: ^bb3
    cir.return %1 : !cir.bool 
  } 
}
```
Lowering the CIR to LLVM using `cir-opt tmp.cir -cir-to-llvm` fails
with:
```
tmp.cir:5:10: error: failed to legalize operation 'llvm.zext' marked as erased
```

The CIR cast `%1 = cir.cast(int_to_bool, %0 : !s32i)` is lowered to a
CIR comparison with zero, which is then lowered to an `LLVM::ICmpOp` and
`LLVM::ZExtOp`.

In the BrCond lowering, the zext is deleted when `zext->use_empty()`,
but during this phase the lowering for the CIR above is not complete
yet, because the zext will still have usage(s) later.

The current check for when the zext is deleted is error-prone and can be
improved.

To fix this, in addition to checking that the use of the zext is empty,
an additional check that the defining operation for the BrCond in the
CIR (the cast operation in this case) is used exactly once is added.

We haven't been able to find the root cause of
llvm#829 just yet, the problem does also not
show up under a ASANified build.

Add some extra information before we crash, hopefully that might shed some
light.

…m#822)

Allow from the clang driver the use of lowering from CIR to MLIR
standard dialect.
Update the test to match the real output when
`-fno-clangir-direct-lowering` is used, or with a combination of both
`-fclangir-direct-lowering` and `-fno-clangir-direct-lowering`.

---------

Co-authored-by: Bruno Cardoso Lopes <[email protected]>
Co-authored-by: Shoaib Meenai <[email protected]>

We can now get the cleanup right for other potential throwing ctors,
still missing LLVM lowering support.

This PR adds a new transformation that transform suitable ternary
operations into select operations.

Currently the "suitable" ternary operations are those ternary operations
whose both branches satisfy either one of the following criteria:

- The branch only contain a single `cir.yield` operation;
- The branch contains a `cir.const` followed by a `cir.yield` that
yields the constant value produced by the `cir.const`.
- ~~The branch contains a `cir.load` followed by a `cir.yield` that
yields the value loaded by the `cir.load`. The load operation cannot be
volatile and must load from an alloca.~~

These criteria are hardcoded now so that simple C/C++ ternary
expressions could be eventually lowered to a `cir.select` operation
instead.

This is permitted by the language, and IRGen emits traps for destructors
other than the base object destructor. Make CIRGen follow suit.

)

The first patch to fix llvm#803 . This PR adds the calling convention
attribute to CallOp directly, which is similar to LLVM, rather than
adding the information to function type, which mimics Clang AST function
type.

The syntax of it in CIR assembly is between the function type and extra
attributes, as follows:

```mlir
%1 = cir.call %fnptr(%a) : (!fnptr, !s32i) -> !s32i cc(spir_kernel) extra(#fn_attr)
```

The verification of direct calls is not included. It will be included in
the next patch extending CIRGen & Lowering.

---

For every builder method of Call Op, an optional parameter `callingConv`
is inserted right before the parameter of extra attribute. However,
apart from the parser / printer, this PR does not introduce any
functional changes.

…anup

… go into entry block