✨ Enable QIR support #335

ystade · 2024-01-18T21:11:07Z

Description

⚠️ This is work in progress! 🚧

QIR is an LLVM IR dialect. This work aims to provide DDsim as a QIR backend. It packs DDsim into a shared library that can be linked with any .ll-file following the QIR specification resulting in an executable.

Checklist:

The pull request only contains commits that are related to it.
I have added appropriate tests and documentation.
I have made sure that all CI jobs on GitHub pass.
The pull request introduces no new warnings and follows the project's style guidelines.

codecov · 2024-01-18T21:16:42Z

Codecov Report

All modified and coverable lines are covered by tests ✅

Additional details and impacted files

@@          Coverage Diff          @@
##            main    #335   +/-   ##
=====================================
  Coverage   92.7%   92.8%           
=====================================
  Files         35      35           
  Lines       2704    2703    -1     
  Branches     349     348    -1     
=====================================
  Hits        2509    2509           
+ Misses       195     194    -1

Flag	Coverage Δ
cpp	`94.6% <ø> (+<0.1%)`	⬆️
python	`87.9% <ø> (ø)`

see 2 files with indirect coverage changes

github-actions · 2024-05-23T07:18:15Z

Cpp-Linter Report ⚠️

Some files did not pass the configured checks!

clang-tidy reports: 623 concern(s)

include/qir/DDsimQir.h:6:10: warning: [modernize-deprecated-headers]

including 'stdbool.h' has no effect in C++; consider removing it
```
#include <stdbool.h>
~~~~~~~~~^~~~~~~~~~~
```

include/qir/DDsimQir.h:21:1: warning: [modernize-use-using]

typedef signed long long int Int;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Int = long long

include/qir/DDsimQir.h:21:9: warning: [google-runtime-int]

consider replacing 'long long' with 'int64'
```
typedef signed long long int Int;
        ^
```

include/qir/DDsimQir.h:22:1: warning: [modernize-use-using]

typedef double               Double;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Double = double

include/qir/DDsimQir.h:23:1: warning: [modernize-use-using]

typedef bool                 Bool;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Bool = bool

include/qir/DDsimQir.h:24:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef enum {
^~~~~~~~~~~~~~
```
include/qir/DDsimQir.h:25:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_I'
```
    PauliId_I = 0,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:26:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_X'
```
    PauliId_X = 1,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:27:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_Z'
```
    PauliId_Z = 2,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:28:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_Y'
```
    PauliId_Y = 3,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:30:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef struct {
^~~~~~~~~~~~~~~~
```
include/qir/DDsimQir.h:37:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void BigInt;
^~~~~~~~~~~~~~~~~~~
using BigInt = void
```
include/qir/DDsimQir.h:42:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Result;
^~~~~~~~~~~~~~~~~~~
using Result = void
```
include/qir/DDsimQir.h:45:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_get_zero', which is a reserved identifier
```
Result* __quantum__rt__result_get_zero();
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:45:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_get_zero'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:48:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_get_one', which is a reserved identifier
```
Result* __quantum__rt__result_get_one();
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:48:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_get_one'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:51:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_equal', which is a reserved identifier
```
Bool __quantum__rt__result_equal(Result*, Result*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:51:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:55:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_update_reference_count', which is a reserved identifier
```
void __quantum__rt__result_update_reference_count(Result*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:55:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:55:60: warning: [google-runtime-int]

void __quantum__rt__result_update_reference_count(Result*, long int);
                                                           ^

include/qir/DDsimQir.h:59:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Qubit;
^~~~~~~~~~~~~~~~~~
using Qubit = void
```
include/qir/DDsimQir.h:64:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef char String;
^~~~~~~~~~~~~~~~~~~
using String = char
```
include/qir/DDsimQir.h:67:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_create', which is a reserved identifier
```
String* __quantum__rt__string_create(const char*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:67:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:70:13: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_get_data', which is a reserved identifier
```
const char* __quantum__rt__string_get_data(String*);
            ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:70:13: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_get_data'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:73:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__string_get_length(String*);
^
```
include/qir/DDsimQir.h:73:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_get_length', which is a reserved identifier
```
long int __quantum__rt__string_get_length(String*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:73:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_get_length'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:77:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_update_reference_count', which is a reserved identifier
```
void __quantum__rt__string_update_reference_count(String*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:77:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:77:60: warning: [google-runtime-int]

void __quantum__rt__string_update_reference_count(String*, long int);
                                                           ^

include/qir/DDsimQir.h:80:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_concatenate', which is a reserved identifier
```
String* __quantum__rt__string_concatenate(String*, String*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:80:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_concatenate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:83:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_equal', which is a reserved identifier
```
Bool __quantum__rt__string_equal(String*, String*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:83:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:86:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__int_to_string', which is a reserved identifier
```
String* __quantum__rt__int_to_string(Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:86:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__int_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:89:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__double_to_string', which is a reserved identifier
```
String* __quantum__rt__double_to_string(Double);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:89:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__double_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:92:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bool_to_string', which is a reserved identifier
```
String* __quantum__rt__bool_to_string(Bool);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:92:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bool_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:95:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_to_string', which is a reserved identifier
```
String* __quantum__rt__result_to_string(Result*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:95:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:98:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__pauli_to_string', which is a reserved identifier
```
String* __quantum__rt__pauli_to_string(Pauli);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:98:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__pauli_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:101:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_to_string', which is a reserved identifier
```
String* __quantum__rt__qubit_to_string(Qubit*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:101:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:104:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__range_to_string', which is a reserved identifier
```
String* __quantum__rt__range_to_string(Range);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:104:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__range_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:107:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_to_string', which is a reserved identifier
```
String* __quantum__rt__bigint_to_string(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:107:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:113:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_create_i64', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_create_i64(Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:113:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_create_i64'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:117:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_create_array', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_create_array(long int, char*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:117:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_create_array'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:117:44: warning: [google-runtime-int]

BigInt* __quantum__rt__bigint_create_array(long int, char*);
                                           ^

include/qir/DDsimQir.h:120:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_get_data', which is a reserved identifier
```
char* __quantum__rt__bigint_get_data(BigInt*);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:120:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_get_data'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:123:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__bigint_get_length(BigInt*);
^
```
include/qir/DDsimQir.h:123:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_get_length', which is a reserved identifier
```
long int __quantum__rt__bigint_get_length(BigInt*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:123:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_get_length'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:127:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_update_reference_count', which is a reserved identifier
```
void __quantum__rt__bigint_update_reference_count(BigInt*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:127:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:127:60: warning: [google-runtime-int]

void __quantum__rt__bigint_update_reference_count(BigInt*, long int);
                                                           ^

include/qir/DDsimQir.h:130:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_negate', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_negate(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:130:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_negate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:133:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_add', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_add(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:133:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_add'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:136:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_subtract', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_subtract(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:136:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_subtract'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:139:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_multiply', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_multiply(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:139:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_multiply'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:142:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_divide', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_divide(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:142:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_divide'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:145:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_modulus', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_modulus(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:145:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_modulus'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:148:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_power', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_power(BigInt*, long int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:148:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_power'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:148:46: warning: [google-runtime-int]

BigInt* __quantum__rt__bigint_power(BigInt*, long int);
                                             ^

include/qir/DDsimQir.h:151:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitand', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitand(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:151:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitand'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:154:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitor', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitor(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:154:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitor'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:157:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitxor', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitxor(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:157:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitxor'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:160:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitnot', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitnot(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:160:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitnot'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:163:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_shiftleft', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_shiftleft(BigInt*, Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:163:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_shiftleft'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:166:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_shiftright', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_shiftright(BigInt*, Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:166:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_shiftright'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:169:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_equal', which is a reserved identifier
```
Bool __quantum__rt__bigint_equal(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:169:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:172:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_greater', which is a reserved identifier
```
Bool __quantum__rt__bigint_greater(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:172:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_greater'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:175:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_greater_eq', which is a reserved identifier
```
Bool __quantum__rt__bigint_greater_eq(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:175:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_greater_eq'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:180:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Tuple;
^~~~~~~~~~~~~~~~~~
using Tuple = void
```
include/qir/DDsimQir.h:183:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_create', which is a reserved identifier
```
Tuple* __quantum__rt__tuple_create(Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:183:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:186:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_copy', which is a reserved identifier
```
Tuple* __quantum__rt__tuple_copy(Tuple*, Bool force);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:186:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:190:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_update_reference_count', which is a reserved identifier
```
void __quantum__rt__tuple_update_reference_count(Tuple*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:190:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:190:58: warning: [google-runtime-int]

void __quantum__rt__tuple_update_reference_count(Tuple*, long int);
                                                         ^

include/qir/DDsimQir.h:193:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_update_alias_count', which is a reserved identifier
```
void __quantum__rt__tuple_update_alias_count(Tuple*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:193:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:193:54: warning: [google-runtime-int]

void __quantum__rt__tuple_update_alias_count(Tuple*, long int);
                                                     ^

include/qir/DDsimQir.h:198:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Array;
^~~~~~~~~~~~~~~~~~
using Array = void
```
include/qir/DDsimQir.h:202:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_create_1d', which is a reserved identifier
```
Array* __quantum__rt__array_create_1d(long int, Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:202:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_create_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:202:39: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
Array* __quantum__rt__array_create_1d(long int, Int);
                                      ^
```
include/qir/DDsimQir.h:205:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_copy', which is a reserved identifier
```
Array* __quantum__rt__array_copy(Array*, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:205:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:208:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_concatenate', which is a reserved identifier
```
Array* __quantum__rt__array_concatenate(Array*, Array*);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:208:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_concatenate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:213:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_slice_1d', which is a reserved identifier
```
Array* __quantum__rt__array_slice_1d(Array*, Range, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:213:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_slice_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:217:5: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_size_1d', which is a reserved identifier
```
Int __quantum__rt__array_get_size_1d(Array*);
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:217:5: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_size_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:220:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_element_ptr_1d', which is a reserved identifier
```
char* __quantum__rt__array_get_element_ptr_1d(Array*, Int);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:220:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_element_ptr_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:224:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_update_reference_count', which is a reserved identifier
```
void __quantum__rt__array_update_reference_count(Array*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:224:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:224:58: warning: [google-runtime-int]

void __quantum__rt__array_update_reference_count(Array*, long int);
                                                         ^

include/qir/DDsimQir.h:227:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_update_alias_count', which is a reserved identifier
```
void __quantum__rt__array_update_alias_count(Array*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:227:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:227:54: warning: [google-runtime-int]

void __quantum__rt__array_update_alias_count(Array*, long int);
                                                     ^

include/qir/DDsimQir.h:233:8: warning: [bugprone-reserved-identifier]

Array* __quantum__rt__array_create(long int, long int, Int*);
       ^
note: this fix will not be applied because it overlaps with another fix

include/qir/DDsimQir.h:233:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_create'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:233:36: warning: [google-runtime-int]

Array* __quantum__rt__array_create(long int, long int, Int*);
                                   ^

include/qir/DDsimQir.h:233:46: warning: [google-runtime-int]

Array* __quantum__rt__array_create(long int, long int, Int*);
                                             ^

include/qir/DDsimQir.h:236:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__array_get_dim(Array*);
^
```
include/qir/DDsimQir.h:236:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_dim', which is a reserved identifier
```
long int __quantum__rt__array_get_dim(Array*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:236:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_dim'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:240:5: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_size', which is a reserved identifier
```
Int __quantum__rt__array_get_size(Array*, long int);
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:240:5: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_size'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:240:43: warning: [google-runtime-int]

Int __quantum__rt__array_get_size(Array*, long int);
                                          ^

include/qir/DDsimQir.h:244:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_element_ptr', which is a reserved identifier
```
char* __quantum__rt__array_get_element_ptr(Array*, Int*);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:244:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_element_ptr'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:251:8: warning: [bugprone-reserved-identifier]

Array* __quantum__rt__array_slice(Array*, long int, Range, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix

include/qir/DDsimQir.h:251:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_slice'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:251:43: warning: [google-runtime-int]

Array* __quantum__rt__array_slice(Array*, long int, Range, Bool);
                                          ^

include/qir/DDsimQir.h:258:8: warning: [bugprone-reserved-identifier]

Array* __quantum__rt__array_project(Array*, long int, Int, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix

include/qir/DDsimQir.h:258:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_project'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:258:45: warning: [google-runtime-int]

Array* __quantum__rt__array_project(Array*, long int, Int, Bool);
                                            ^

include/qir/DDsimQir.h:263:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Callable;
^~~~~~~~~~~~~~~~~~~~~
using Callable = void
```

include/qir/DDsimQir.h:267:11: warning: [bugprone-reserved-identifier]

Callable* __quantum__rt__callable_create(void (*f[4])(Tuple*, Tuple*, Tuple*), void (*m[2])(Tuple*, Tuple*, Tuple*), Tuple*);
          ^
note: this fix will not be applied because it overlaps with another fix

include/qir/DDsimQir.h:267:11: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:271:11: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_copy', which is a reserved identifier
```
Callable* __quantum__rt__callable_copy(Callable*, Bool);
          ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:271:11: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:274:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_invoke', which is a reserved identifier
```
void __quantum__rt__callable_invoke(Callable*, Tuple*, Tuple*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:274:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_invoke'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:277:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_make_adjoint', which is a reserved identifier
```
void __quantum__rt__callable_make_adjoint(Callable*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:277:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_make_adjoint'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:280:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_make_controlled', which is a reserved identifier
```
void __quantum__rt__callable_make_controlled(Callable*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:280:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_make_controlled'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:284:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_update_reference_count', which is a reserved identifier
```
void __quantum__rt__callable_update_reference_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:284:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:284:64: warning: [google-runtime-int]

void __quantum__rt__callable_update_reference_count(Callable*, long int);
                                                               ^

include/qir/DDsimQir.h:287:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_update_alias_count', which is a reserved identifier
```
void __quantum__rt__callable_update_alias_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:287:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:287:60: warning: [google-runtime-int]

void __quantum__rt__callable_update_alias_count(Callable*, long int);
                                                           ^

include/qir/DDsimQir.h:291:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__capture_update_reference_count', which is a reserved identifier
```
void __quantum__rt__capture_update_reference_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:291:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__capture_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:291:63: warning: [google-runtime-int]

void __quantum__rt__capture_update_reference_count(Callable*, long int);
                                                              ^

include/qir/DDsimQir.h:295:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__capture_update_alias_count', which is a reserved identifier
```
void __quantum__rt__capture_update_alias_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:295:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__capture_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:295:59: warning: [google-runtime-int]

void __quantum__rt__capture_update_alias_count(Callable*, long int);
                                                          ^

include/qir/DDsimQir.h:301:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__message', which is a reserved identifier
```
void __quantum__rt__message(String* msg);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:301:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__message'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:304:16: warning: [bugprone-reserved-identifier]

_Noreturn void __quantum__rt__fail(String* msg);
               ^
note: this fix will not be applied because it overlaps with another fix

include/qir/DDsimQir.h:304:16: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__fail'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:310:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_allocate', which is a reserved identifier
```
Qubit* __quantum__rt__qubit_allocate();
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:310:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_allocate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:313:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_allocate_array', which is a reserved identifier
```
Array* __quantum__rt__qubit_allocate_array(Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:313:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_allocate_array'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:316:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_release', which is a reserved identifier
```
void __quantum__rt__qubit_release(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:316:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_release'
```
note: this fix will not be applied because it overlaps with another fix
```

Have any feedback or feature suggestions? Share it here.

update readme to describe how to generate a working example

uncomment unsued library to make example work

this files was created by running the python file BellPair.py. See also https://github.com/cda-tum/mqt-ddsim/blob/wip-qir-support/scripts/qir/examples/BellPair.py

completing the cmake script to build an executable for the BellPair example that functions with the QuantumComputation library from MQT-Core

ystade and others added 2 commits January 18, 2024 21:37

✨ Start a QIR interafce

f4a8983

🎨 pre-commit fixes

9ad91fa

ystade self-assigned this Jan 18, 2024

ystade marked this pull request as draft January 18, 2024 21:12

ystade added the feature New feature or request label Jan 18, 2024

ystade and others added 5 commits May 23, 2024 09:12

🎨 Cleanup src and cmake file

d5d9206

🧪 Add failing test for QIR

f0c5223

🐛 Fix malloc

7365801

🔥 Comment out non working code

b7011f5

🎨 pre-commit fixes

336d7af

Erik Weilandt added 3 commits May 23, 2024 09:35

update QIR Readme

f7aaaae

update readme to describe how to generate a working example

fix final issue for working example

b7e6eaa

uncomment unsued library to make example work

Update MQT core

073036f

ErikLahm self-assigned this May 23, 2024

Erik Weilandt added 3 commits May 31, 2024 11:44

add BellPair_py.ll

8d05c7f

this files was created by running the python file BellPair.py. See also https://github.com/cda-tum/mqt-ddsim/blob/wip-qir-support/scripts/qir/examples/BellPair.py

update Readme to describe current state

2e2ce71

set up CMakeLists.txt for QIR

c091d39

completing the cmake script to build an executable for the BellPair example that functions with the QuantumComputation library from MQT-Core

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

✨ Enable QIR support #335

✨ Enable QIR support #335

ystade commented Jan 18, 2024 •

edited

Loading

codecov bot commented Jan 18, 2024 •

edited

Loading

github-actions bot commented May 23, 2024

✨ Enable QIR support #335

Are you sure you want to change the base?

✨ Enable QIR support #335

Conversation

ystade commented Jan 18, 2024 • edited Loading

Description

Checklist:

codecov bot commented Jan 18, 2024 • edited Loading

Codecov Report

github-actions bot commented May 23, 2024

Cpp-Linter Report ⚠️

ystade commented Jan 18, 2024 •

edited

Loading

codecov bot commented Jan 18, 2024 •

edited

Loading