From 005da771115ddac4e7cb272ae332cd754e78ad45 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Thu, 11 Mar 2021 10:20:56 -0800 Subject: [PATCH 01/14] Changed quantum__rt__heap_alloc() signature --- src/QirRuntime/lib/QIR/bridge-rt.ll | 6 +++--- src/QirRuntime/lib/QIR/utils.cpp | 9 +++++++-- src/QirRuntime/public/QirRuntime.hpp | 2 +- 3 files changed, 11 insertions(+), 6 deletions(-) diff --git a/src/QirRuntime/lib/QIR/bridge-rt.ll b/src/QirRuntime/lib/QIR/bridge-rt.ll index f27357e918c..802ec1a70d4 100644 --- a/src/QirRuntime/lib/QIR/bridge-rt.ll +++ b/src/QirRuntime/lib/QIR/bridge-rt.ll @@ -37,7 +37,7 @@ ;------------------------------------------------------------------------------ ; classical ; -declare i8* @quantum__rt__heap_alloc(i32) +declare i8* @quantum__rt__heap_alloc(i64) declare void @quantum__rt__heap_free(i8*) declare void @quantum__rt__fail(%"struct.QirString"*) @@ -111,8 +111,8 @@ declare %"struct.QirString"* @quantum__rt__range_to_string(%"struct.QirRange"* d ;------------------------------------------------------------------------------ ; classical bridge ; -define dllexport i8* @__quantum__rt__heap_alloc(i32 %size) { - %mem = call i8* @quantum__rt__heap_alloc(i32 %size) +define dllexport i8* @__quantum__rt__heap_alloc(i64 %size) { + %mem = call i8* @quantum__rt__heap_alloc(i64 %size) ret i8* %mem } diff --git a/src/QirRuntime/lib/QIR/utils.cpp b/src/QirRuntime/lib/QIR/utils.cpp index 6f024cdfafe..cd5dbb6daef 100644 --- a/src/QirRuntime/lib/QIR/utils.cpp +++ b/src/QirRuntime/lib/QIR/utils.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include "QirRuntime.hpp" @@ -20,9 +21,13 @@ std::unordered_set& UseMemoryTracker() extern "C" { // Allocate a block of memory on the heap. - char* quantum__rt__heap_alloc(int size) // NOLINT + char* quantum__rt__heap_alloc(uint64_t size) // NOLINT { - char* buffer = new char[size]; + char* buffer = new (std::nothrow) char[size]; + if(buffer == nullptr) + { + quantum__rt__fail(quantum__rt__string_create("Allocation Failed")); + } #ifndef NDEBUG UseMemoryTracker().insert(buffer); #endif diff --git a/src/QirRuntime/public/QirRuntime.hpp b/src/QirRuntime/public/QirRuntime.hpp index eedcdf659b4..10143446e48 100644 --- a/src/QirRuntime/public/QirRuntime.hpp +++ b/src/QirRuntime/public/QirRuntime.hpp @@ -56,7 +56,7 @@ extern "C" // ------------------------------------------------------------------------ // Allocate a block of memory on the heap. - QIR_SHARED_API char* quantum__rt__heap_alloc(int size); // NOLINT + QIR_SHARED_API char* quantum__rt__heap_alloc(uint64_t size); // NOLINT // Release a block of allocated heap memory. QIR_SHARED_API void quantum__rt__heap_free(char* buffer); // NOLINT From 9ddc63b03a571fe3c473cf1fcc96e86815d5a06c Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Thu, 11 Mar 2021 13:27:06 -0800 Subject: [PATCH 02/14] Added quantum__rt_string_get_(data|length) --- src/QirRuntime/lib/QIR/bridge-rt.ll | 15 +++++++++++++++ src/QirRuntime/lib/QIR/strings.cpp | 11 +++++++++++ src/QirRuntime/public/QirRuntime.hpp | 8 ++++++++ 3 files changed, 34 insertions(+) diff --git a/src/QirRuntime/lib/QIR/bridge-rt.ll b/src/QirRuntime/lib/QIR/bridge-rt.ll index 802ec1a70d4..d8a56e097ee 100644 --- a/src/QirRuntime/lib/QIR/bridge-rt.ll +++ b/src/QirRuntime/lib/QIR/bridge-rt.ll @@ -101,6 +101,8 @@ declare %"struct.QirString"* @quantum__rt__result_to_string(%class.RESULT*) declare %"struct.QirString"* @quantum__rt__pauli_to_string(%PauliId) declare %"struct.QirString"* @quantum__rt__qubit_to_string(%class.QUBIT*) declare %"struct.QirString"* @quantum__rt__range_to_string(%"struct.QirRange"* dereferenceable(24) %range) +declare i8* @quantum__rt_string_get_data(%"struct.QirString"* %str) +declare i32 @quantum__rt_string_get_length(%"struct.QirString"* %str) @@ -458,6 +460,19 @@ define dllexport %String* @__quantum__rt__range_to_string(%Range %.range) { ret %String* %.str } +define i8* @__quantum__rt_string_get_data(%String* %.str) { + %str = bitcast %String* %.str to %"struct.QirString"* + %result = call i8* @quantum__rt_string_get_data(%"struct.QirString"* %str) + ret i8* %result +} + +define i32 @__quantum__rt_string_get_length(%String* %.str) { + %str = bitcast %String* %.str to %"struct.QirString"* + %result = call i32 @quantum__rt_string_get_length(%"struct.QirString"* %str) + ret i32 %result +} + + ;------------------------------------------------------------------------------ ; bigints bridge ; diff --git a/src/QirRuntime/lib/QIR/strings.cpp b/src/QirRuntime/lib/QIR/strings.cpp index 21f3b571d14..49a2c40dffb 100644 --- a/src/QirRuntime/lib/QIR/strings.cpp +++ b/src/QirRuntime/lib/QIR/strings.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include "QirTypes.hpp" #include "QirRuntime.hpp" @@ -155,6 +156,16 @@ extern "C" return quantum__rt__string_create(oss.str().c_str()); } + const char* quantum__rt_string_get_data(QirString* str) // NOLINT + { + return str->str.c_str(); + } + + uint32_t quantum__rt_string_get_length(QirString* str) // NOLINT + { + return str->str.size(); + } + // Implemented in delegated.cpp: // QirString* quantum__rt__qubit_to_string(QUBIT* qubit); // NOLINT diff --git a/src/QirRuntime/public/QirRuntime.hpp b/src/QirRuntime/public/QirRuntime.hpp index 10143446e48..bb7758515c1 100644 --- a/src/QirRuntime/public/QirRuntime.hpp +++ b/src/QirRuntime/public/QirRuntime.hpp @@ -228,6 +228,14 @@ extern "C" // Returns a string representation of the range. QIR_SHARED_API QirString* quantum__rt__range_to_string(const QirRange&); // NOLINT + // Returns a pointer to an array that contains a null-terminated sequence of characters + // (i.e., a C-string) representing the current value of the string object. + QIR_SHARED_API const char* quantum__rt_string_get_data(QirString* str); // NOLINT + + // Returns the length of the string, in terms of bytes. + // http://www.cplusplus.com/reference/string/string/size/ + QIR_SHARED_API uint32_t quantum__rt_string_get_length(QirString* str); // NOLINT + // Returns a string representation of the big integer. // TODO QIR_SHARED_API QirString* quantum__rt__bigint_to_string(QirBigInt*); // NOLINT From 477b560a1cd4c826b47c6422f5c3c657d5d4e78a Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Thu, 11 Mar 2021 17:20:36 -0800 Subject: [PATCH 03/14] Changed the __quantum__rt__*_update_reference_count signature --- src/QirRuntime/lib/QIR/bridge-rt.ll | 17 ++++++----------- .../test/QIR-static/qir-test-noqsharp.ll | 6 +++--- 2 files changed, 9 insertions(+), 14 deletions(-) diff --git a/src/QirRuntime/lib/QIR/bridge-rt.ll b/src/QirRuntime/lib/QIR/bridge-rt.ll index d8a56e097ee..dd79fa7f7b3 100644 --- a/src/QirRuntime/lib/QIR/bridge-rt.ll +++ b/src/QirRuntime/lib/QIR/bridge-rt.ll @@ -174,9 +174,8 @@ define dllexport i1 @__quantum__rt__result_equal(%Result* %.r1, %Result* %.r2) { ret i1 %c } -define dllexport void @__quantum__rt__result_update_reference_count(%Result* %.r, i64 %.c) { +define dllexport void @__quantum__rt__result_update_reference_count(%Result* %.r, i32 %c) { %r = bitcast %Result* %.r to %class.RESULT* - %c = trunc i64 %.c to i32 call void @quantum__rt__result_update_reference_count(%class.RESULT* %r, i32 %c) ret void } @@ -278,9 +277,8 @@ define dllexport %Array* @__quantum__rt__array_slice_1d(%Array* %.ar, %Range %.r ret %Array* %.slice } -define dllexport void @__quantum__rt__array_update_reference_count(%Array* %.ar, i64 %.c) { +define dllexport void @__quantum__rt__array_update_reference_count(%Array* %.ar, i32 %c) { %ar = bitcast %Array* %.ar to %"struct.QirArray"* - %c = trunc i64 %.c to i32 call void @quantum__rt__array_update_reference_count(%"struct.QirArray"* %ar, i32 %c) ret void } @@ -301,9 +299,8 @@ define dllexport %Tuple* @__quantum__rt__tuple_create(i64 %size) { ret %Tuple* %.th } -define dllexport void @__quantum__rt__tuple_update_reference_count(%Tuple* %.th, i64 %.c) { +define dllexport void @__quantum__rt__tuple_update_reference_count(%Tuple* %.th, i32 %c) { %th = bitcast %Tuple* %.th to i8* - %c = trunc i64 %.c to i32 call void @quantum__rt__tuple_update_reference_count(i8* %th, i32 %c) ret void } @@ -318,9 +315,8 @@ define dllexport void @__quantum__rt__tuple_update_alias_count(%Tuple* %.th, i64 ;------------------------------------------------------------------------------ ; callables bridge ; -define dllexport void @__quantum__rt__callable_update_reference_count(%Callable* %.clb, i64 %.c) { +define dllexport void @__quantum__rt__callable_update_reference_count(%Callable* %.clb, i32 %c) { %clb = bitcast %Callable* %.clb to %"struct.QirCallable"* - %c = trunc i64 %.c to i32 call void @quantum__rt__callable_update_reference_count(%"struct.QirCallable"* %clb, i32 %c) ret void } @@ -389,9 +385,8 @@ define dllexport %String* @__quantum__rt__string_create(i32 %length_ignored, i8* ret %String* %.str } -define dllexport void @__quantum__rt__string_update_reference_count(%String* %.str, i64 %.c) { +define dllexport void @__quantum__rt__string_update_reference_count(%String* %.str, i32 %c) { %str = bitcast %String* %.str to %"struct.QirString"* - %c = trunc i64 %.c to i32 call void @quantum__rt__string_update_reference_count(%"struct.QirString"* %str, i32 %c) ret void } @@ -479,7 +474,7 @@ define i32 @__quantum__rt_string_get_length(%String* %.str) { ; NYI: ;define dllexport %BigInt* @__quantum__rt__bigint_create_i64(i64) ;define dllexport %BigInt* @__quantum__rt__bigint_create_array(i32, [0 x i8]) -;define dllexport void @__quantum__rt__bigint_update_reference_count(%BigInt*, i64) +;define dllexport void @__quantum__rt__bigint_update_reference_count(%BigInt*, i32) ;define dllexport %BigInt* @__quantum__rt__bigint_negate(%BigInt*) ;define dllexport %BigInt* @__quantum__rt__bigint_add(%BigInt*, %BigInt*) ;define dllexport %BigInt* @__quantum__rt__bigint_subtract(%BigInt*, %BigInt*) diff --git a/src/QirRuntime/test/QIR-static/qir-test-noqsharp.ll b/src/QirRuntime/test/QIR-static/qir-test-noqsharp.ll index 72ef01af60c..cce6f8f54c5 100644 --- a/src/QirRuntime/test/QIR-static/qir-test-noqsharp.ll +++ b/src/QirRuntime/test/QIR-static/qir-test-noqsharp.ll @@ -8,7 +8,7 @@ declare i64 @__quantum__rt__array_get_size(%Array*, i32) declare i8* @__quantum__rt__array_get_element_ptr(%Array*, ...) declare i32 @__quantum__rt__array_get_dim(%Array*) declare %Array* @__quantum__rt__array_project(%Array*, i32, i64) -declare void @__quantum__rt__array_update_reference_count(%Array*, i64) +declare void @__quantum__rt__array_update_reference_count(%Array*, i32) declare void @DebugLog(i64) ; manually authored test for multi-dimensional arrays (Q# doesn't support multi-dimentional arrays yet) @@ -25,8 +25,8 @@ define i64 @TestMultidimArrays(i8 %val, i64 %dim0, i64 %dim1, i64 %dim2) %project_val = load i8, i8* %project_elem_ptr %val64 = sext i8 %project_val to i64 - call void @__quantum__rt__array_update_reference_count(%Array* %.ar, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %.project, i64 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %.ar, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %.project, i32 -1) %t1 = add i64 %project_dim0, %project_dim1 %t2 = sext i32 %project_dims to i64 From 0640532dd206ecf30caf2a87dc330a0e08303de7 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Thu, 11 Mar 2021 17:23:57 -0800 Subject: [PATCH 04/14] Changed the __quantum__rt__string_create signature --- src/QirRuntime/lib/QIR/bridge-rt.ll | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/QirRuntime/lib/QIR/bridge-rt.ll b/src/QirRuntime/lib/QIR/bridge-rt.ll index dd79fa7f7b3..bfae7c82e72 100644 --- a/src/QirRuntime/lib/QIR/bridge-rt.ll +++ b/src/QirRuntime/lib/QIR/bridge-rt.ll @@ -379,7 +379,7 @@ define dllexport void @__quantum__rt__callable_memory_management(i32 %index, %Ca ; NYI: ;define dllexport %String* @__quantum__rt__bigint_to_string(%BigInt*) -define dllexport %String* @__quantum__rt__string_create(i32 %length_ignored, i8* %null_terminated_buffer) { +define dllexport %String* @__quantum__rt__string_create(i8* %null_terminated_buffer) { %str = call %"struct.QirString"* @quantum__rt__string_create(i8* %null_terminated_buffer) %.str = bitcast %"struct.QirString"* %str to %String* ret %String* %.str From 5d66be14ef885ef37bbd966e466f5451bc06a820 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Thu, 11 Mar 2021 17:35:25 -0800 Subject: [PATCH 05/14] Added to quantum__rt__qubit_release_array() the array release --- src/QirRuntime/lib/QIR/arrays.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/QirRuntime/lib/QIR/arrays.cpp b/src/QirRuntime/lib/QIR/arrays.cpp index 00d8d9e19c6..54c68d08b82 100644 --- a/src/QirRuntime/lib/QIR/arrays.cpp +++ b/src/QirRuntime/lib/QIR/arrays.cpp @@ -231,6 +231,8 @@ extern "C" qa->ownsQubits = false; } + + quantum__rt__array_update_reference_count(qa, -1); } QirArray* quantum__rt__array_create_1d(int32_t itemSizeInBytes, int64_t count_items) From c35786303b43ad990ce55d4ba4fff45504617c21 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Thu, 11 Mar 2021 17:41:07 -0800 Subject: [PATCH 06/14] Changed the __quantum__rt__.*_update_alias_count() signature --- src/QirRuntime/lib/QIR/bridge-rt.ll | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/QirRuntime/lib/QIR/bridge-rt.ll b/src/QirRuntime/lib/QIR/bridge-rt.ll index bfae7c82e72..f8196142d54 100644 --- a/src/QirRuntime/lib/QIR/bridge-rt.ll +++ b/src/QirRuntime/lib/QIR/bridge-rt.ll @@ -283,9 +283,8 @@ define dllexport void @__quantum__rt__array_update_reference_count(%Array* %.ar, ret void } -define dllexport void @__quantum__rt__array_update_alias_count(%Array* %.ar, i64 %.c) { +define dllexport void @__quantum__rt__array_update_alias_count(%Array* %.ar, i32 %c) { %ar = bitcast %Array* %.ar to %"struct.QirArray"* - %c = trunc i64 %.c to i32 call void @quantum__rt__array_update_alias_count(%"struct.QirArray"* %ar, i32 %c) ret void } @@ -305,9 +304,8 @@ define dllexport void @__quantum__rt__tuple_update_reference_count(%Tuple* %.th, ret void } -define dllexport void @__quantum__rt__tuple_update_alias_count(%Tuple* %.th, i64 %.c) { +define dllexport void @__quantum__rt__tuple_update_alias_count(%Tuple* %.th, i32 %c) { %th = bitcast %Tuple* %.th to i8* - %c = trunc i64 %.c to i32 call void @quantum__rt__tuple_update_alias_count(i8* %th, i32 %c) ret void } @@ -321,9 +319,8 @@ define dllexport void @__quantum__rt__callable_update_reference_count(%Callable* ret void } -define dllexport void @__quantum__rt__callable_update_alias_count(%Callable* %.clb, i64 %.c) { +define dllexport void @__quantum__rt__callable_update_alias_count(%Callable* %.clb, i32 %c) { %clb = bitcast %Callable* %.clb to %"struct.QirCallable"* - %c = trunc i64 %.c to i32 call void @quantum__rt__callable_update_alias_count(%"struct.QirCallable"* %clb, i32 %c) ret void } From 9194c1e144585e019c6fad8ea2562b61ec26a659 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Mon, 15 Mar 2021 12:58:16 -0700 Subject: [PATCH 07/14] Added __quantum__rt__result_get_zero and a __quantum__rt__result_get_one --- src/QirRuntime/lib/QIR/bridge-rt.ll | 14 ++++++++++++++ src/QirRuntime/lib/QIR/delegated.cpp | 4 ++-- .../lib/QSharpFoundation/conditionals.cpp | 2 +- src/QirRuntime/public/QirRuntime.hpp | 5 ++--- src/QirRuntime/public/QirTypes.hpp | 2 +- 5 files changed, 20 insertions(+), 7 deletions(-) diff --git a/src/QirRuntime/lib/QIR/bridge-rt.ll b/src/QirRuntime/lib/QIR/bridge-rt.ll index f8196142d54..844e7008463 100644 --- a/src/QirRuntime/lib/QIR/bridge-rt.ll +++ b/src/QirRuntime/lib/QIR/bridge-rt.ll @@ -48,6 +48,8 @@ declare %class.QUBIT* @quantum__rt__qubit_allocate() declare void @quantum__rt__qubit_release(%class.QUBIT*) declare i1 @quantum__rt__result_equal(%class.RESULT*, %class.RESULT*) declare void @quantum__rt__result_update_reference_count(%class.RESULT* %r, i32 %c) +declare %class.RESULT* @quantum__rt__result_get_zero() +declare %class.RESULT* @quantum__rt__result_get_one() ;------------------------------------------------------------------------------ ; arrays @@ -180,6 +182,18 @@ define dllexport void @__quantum__rt__result_update_reference_count(%Result* %.r ret void } +define dllexport %Result* @__quantum__rt__result_get_zero() { + %result = call %class.RESULT* @quantum__rt__result_get_zero() + %.result = bitcast %class.RESULT* %result to %Result* + ret %Result* %.result +} + +define dllexport %Result* @__quantum__rt__result_get_one() { + %result = call %class.RESULT* @quantum__rt__result_get_one() + %.result = bitcast %class.RESULT* %result to %Result* + ret %Result* %.result +} + ; ----------------------------------------------------------------------------- ; arrays bridge diff --git a/src/QirRuntime/lib/QIR/delegated.cpp b/src/QirRuntime/lib/QIR/delegated.cpp index 7100fcef9aa..8d466b086f4 100644 --- a/src/QirRuntime/lib/QIR/delegated.cpp +++ b/src/QirRuntime/lib/QIR/delegated.cpp @@ -27,12 +27,12 @@ std::unordered_map& AllocatedResults() extern "C" { - Result quantum__rt__result_zero() + Result quantum__rt__result_get_zero() { return Microsoft::Quantum::g_context->driver->UseZero(); } - Result quantum__rt__result_one() + Result quantum__rt__result_get_one() { return Microsoft::Quantum::g_context->driver->UseOne(); } diff --git a/src/QirRuntime/lib/QSharpFoundation/conditionals.cpp b/src/QirRuntime/lib/QSharpFoundation/conditionals.cpp index 048ce01eadb..64e46c846f2 100644 --- a/src/QirRuntime/lib/QSharpFoundation/conditionals.cpp +++ b/src/QirRuntime/lib/QSharpFoundation/conditionals.cpp @@ -31,7 +31,7 @@ extern "C" { void quantum__qis__applyifelseintrinsic__body(RESULT* r, QirCallable* clbOnZero, QirCallable* clbOnOne) { - QirCallable* clb = quantum__rt__result_equal(r, quantum__rt__result_zero()) ? clbOnZero : clbOnOne; + QirCallable* clb = quantum__rt__result_equal(r, quantum__rt__result_get_zero()) ? clbOnZero : clbOnOne; clb->Invoke(); } diff --git a/src/QirRuntime/public/QirRuntime.hpp b/src/QirRuntime/public/QirRuntime.hpp index bb7758515c1..194dbdc9b81 100644 --- a/src/QirRuntime/public/QirRuntime.hpp +++ b/src/QirRuntime/public/QirRuntime.hpp @@ -78,9 +78,8 @@ extern "C" // becomes 0. The behavior is undefined if the reference count becomes negative. QIR_SHARED_API void quantum__rt__result_update_reference_count(RESULT*, int32_t); // NOLINT - // Not in the QIR spec right now - QIR_SHARED_API RESULT* quantum__rt__result_one(); // NOLINT - QIR_SHARED_API RESULT* quantum__rt__result_zero(); // NOLINT + QIR_SHARED_API RESULT* quantum__rt__result_get_one(); // NOLINT + QIR_SHARED_API RESULT* quantum__rt__result_get_zero(); // NOLINT // ------------------------------------------------------------------------ // Tuples diff --git a/src/QirRuntime/public/QirTypes.hpp b/src/QirRuntime/public/QirTypes.hpp index 6b144975346..46b73e37a65 100644 --- a/src/QirRuntime/public/QirTypes.hpp +++ b/src/QirRuntime/public/QirTypes.hpp @@ -63,7 +63,7 @@ struct QIR_SHARED_API QirTupleHeader { int32_t refCount = 0; int32_t aliasCount = 0; // used to enable copy elision, see the QIR specifications for details - int32_t tupleSize = 0; // when creating the tuple, must be set to the size of the tuple's data buffer + int32_t tupleSize = 0; // when creating the tuple, must be set to the size of the tuple's data buffer (in bytes) // flexible array member, must be last in the struct char data[]; From d6462c4fb4b1556e392c8895b8e1830fc7120699 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Tue, 16 Mar 2021 17:59:09 -0700 Subject: [PATCH 08/14] Added __quantum__rt__capture_update_reference_count and __quantum__rt__capture_update_alias_count --- src/QirRuntime/lib/QIR/bridge-rt.ll | 27 ++++++++++++++++++++++++--- src/QirRuntime/lib/QIR/callables.cpp | 4 ++-- src/QirRuntime/public/QirRuntime.hpp | 5 ++--- src/QirRuntime/public/QirTypes.hpp | 4 ++-- 4 files changed, 30 insertions(+), 10 deletions(-) diff --git a/src/QirRuntime/lib/QIR/bridge-rt.ll b/src/QirRuntime/lib/QIR/bridge-rt.ll index 844e7008463..ee8e3b7b28c 100644 --- a/src/QirRuntime/lib/QIR/bridge-rt.ll +++ b/src/QirRuntime/lib/QIR/bridge-rt.ll @@ -87,7 +87,7 @@ declare %"struct.QirCallable"* @quantum__rt__callable_copy(%"struct.QirCallable" declare %"struct.QirCallable"* @quantum__rt__callable_make_adjoint(%"struct.QirCallable"*) declare %"struct.QirCallable"* @quantum__rt__callable_make_controlled(%"struct.QirCallable"*) declare void @quantum__rt__callable_update_alias_count(%"struct.QirCallable"*, i32) -declare void @quantum__rt__callable_memory_management(i32, %"struct.QirCallable"*, i64) +declare void @quantum__rt__callable_memory_management(i32, %"struct.QirCallable"*, i32) ;------------------------------------------------------------------------------ ; strings @@ -379,11 +379,32 @@ define dllexport %Callable* @__quantum__rt__callable_make_controlled(%Callable* ret %Callable* %.clb_cnt } -define dllexport void @__quantum__rt__callable_memory_management(i32 %index, %Callable* %.clb, i64 %parameter) { +; After both the compiler and runtime are in sync with https://github.com/microsoft/qsharp-language/pull/83: +; Regenerate the following .ll files with the updated compiler such that they don't call this function any more: +; test\FullstateSimulator\qir-test-simulator.ll +; test\QIR-tracer\tracer-qir-lnx.ll +; test\QIR-tracer\tracer-qir-win.ll +; Remove this function. +; Resolve https://github.com/microsoft/qsharp-runtime/issues/568 (Remove `__quantum__rt__callable_memory_management()`) +define dllexport void @__quantum__rt__callable_memory_management(i32 %index, %Callable* %.clb, i64 %.parameter) { %clb = bitcast %Callable* %.clb to %"struct.QirCallable"* - call void @quantum__rt__callable_memory_management(i32 %index, %"struct.QirCallable"* %clb, i64 %parameter) + %parameter = trunc i64 %.parameter to i32 + call void @quantum__rt__callable_memory_management(i32 %index, %"struct.QirCallable"* %clb, i32 %parameter) ret void } + +define dllexport void @__quantum__rt__capture_update_reference_count(%Callable* %.clb, i32 %count) { + %clb = bitcast %Callable* %.clb to %"struct.QirCallable"* + call void @quantum__rt__callable_memory_management(i32 0, %"struct.QirCallable"* %clb, i32 %count) + ret void +} + +define dllexport void @__quantum__rt__capture_update_alias_count(%Callable* %.clb, i32 %count) { + %clb = bitcast %Callable* %.clb to %"struct.QirCallable"* + call void @quantum__rt__callable_memory_management(i32 1, %"struct.QirCallable"* %clb, i32 %count) + ret void +} + ;------------------------------------------------------------------------------ ; strings bridge ; diff --git a/src/QirRuntime/lib/QIR/callables.cpp b/src/QirRuntime/lib/QIR/callables.cpp index 454eb4f3dbf..503ae8c1bf6 100644 --- a/src/QirRuntime/lib/QIR/callables.cpp +++ b/src/QirRuntime/lib/QIR/callables.cpp @@ -153,7 +153,7 @@ extern "C" callable->ApplyFunctor(QirCallable::Controlled); } - void quantum__rt__callable_memory_management(int32_t index, QirCallable* callable, int64_t parameter) + void quantum__rt__callable_memory_management(int32_t index, QirCallable* callable, int32_t parameter) { callable->InvokeCaptureCallback(index, parameter); } @@ -443,7 +443,7 @@ void QirCallable::ApplyFunctor(int functor) } } -void QirCallable::InvokeCaptureCallback(int index, int64_t parameter) +void QirCallable::InvokeCaptureCallback(int32_t index, int32_t parameter) { assert(index >= 0 && index < QirCallable::CaptureCallbacksTableSize && "Capture callback index out of range"); diff --git a/src/QirRuntime/public/QirRuntime.hpp b/src/QirRuntime/public/QirRuntime.hpp index 194dbdc9b81..f8c601f1b79 100644 --- a/src/QirRuntime/public/QirRuntime.hpp +++ b/src/QirRuntime/public/QirRuntime.hpp @@ -159,7 +159,6 @@ extern "C" // Initializes the callable with the provided function table and capture tuple. The capture tuple pointer // should be null if there is no capture. typedef void (*t_CallableEntry)(PTuple, PTuple, PTuple); // NOLINT - typedef void (*t_CaptureCallback)(PTuple, int64_t); // NOLINT QIR_SHARED_API QirCallable* quantum__rt__callable_create(t_CallableEntry*, t_CaptureCallback*, PTuple); // NOLINT // Adds the given integer value to the reference count for the callable. Deallocates the callable if the reference @@ -183,9 +182,9 @@ extern "C" QIR_SHARED_API void quantum__rt__callable_make_controlled(QirCallable*); // NOLINT // Invokes the function at the given index in the memory management table of the callable with the capture tuple and - // the given 64-bit integer. Does nothing if if the memory management table pointer or the function pointer at that + // the given 32-bit integer. Does nothing if the memory management table pointer or the function pointer at that // index is null. - QIR_SHARED_API void quantum__rt__callable_memory_management(int32_t, QirCallable*, int64_t); // NOLINT + QIR_SHARED_API void quantum__rt__callable_memory_management(int32_t, QirCallable*, int32_t); // NOLINT // ------------------------------------------------------------------------ // Strings diff --git a/src/QirRuntime/public/QirTypes.hpp b/src/QirRuntime/public/QirTypes.hpp index 46b73e37a65..02b1d686f68 100644 --- a/src/QirRuntime/public/QirTypes.hpp +++ b/src/QirRuntime/public/QirTypes.hpp @@ -121,7 +121,7 @@ static_assert( QirCallable ======================================================================================================================*/ typedef void (*t_CallableEntry)(PTuple, PTuple, PTuple); -typedef void (*t_CaptureCallback)(PTuple, int64_t); +typedef void (*t_CaptureCallback)(PTuple, int32_t); struct QIR_SHARED_API QirCallable { static int constexpr Adjoint = 1; @@ -171,5 +171,5 @@ struct QIR_SHARED_API QirCallable void Invoke(); // a shortcut to invoke a callable with no arguments and Unit result void ApplyFunctor(int functor); - void InvokeCaptureCallback(int index, int64_t parameter); + void InvokeCaptureCallback(int32_t index, int32_t parameter); }; \ No newline at end of file From 7f642576f92a8a26b036a6aa8bff9139902c6b13 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Tue, 16 Mar 2021 23:00:44 -0700 Subject: [PATCH 09/14] Added __quantum__rt__memory_allocate() --- src/QirRuntime/lib/QIR/bridge-rt.ll | 7 +++++++ src/QirRuntime/lib/QIR/utils.cpp | 6 ++++++ src/QirRuntime/public/QirRuntime.hpp | 3 +++ 3 files changed, 16 insertions(+) diff --git a/src/QirRuntime/lib/QIR/bridge-rt.ll b/src/QirRuntime/lib/QIR/bridge-rt.ll index ee8e3b7b28c..950a26abf67 100644 --- a/src/QirRuntime/lib/QIR/bridge-rt.ll +++ b/src/QirRuntime/lib/QIR/bridge-rt.ll @@ -39,6 +39,7 @@ ; declare i8* @quantum__rt__heap_alloc(i64) declare void @quantum__rt__heap_free(i8*) +declare i8* @quantum__rt__memory_allocate(i64) declare void @quantum__rt__fail(%"struct.QirString"*) ;------------------------------------------------------------------------------ @@ -125,6 +126,12 @@ define dllexport void @__quantum__rt__heap_free(i8* %mem) { ret void } +; Returns a pointer to the malloc-allocated block. +define dllexport i8* @__quantum__rt__memory_allocate(i64 %size) { + %result = call i8* @quantum__rt__memory_allocate(i64 %size) + ret i8* %result +} + define dllexport void @__quantum__rt__fail(%String* %.str) { %str = bitcast %String* %.str to %"struct.QirString"* call void @quantum__rt__fail(%"struct.QirString"* %str) diff --git a/src/QirRuntime/lib/QIR/utils.cpp b/src/QirRuntime/lib/QIR/utils.cpp index cd5dbb6daef..00bd1959ed5 100644 --- a/src/QirRuntime/lib/QIR/utils.cpp +++ b/src/QirRuntime/lib/QIR/utils.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include "QirRuntime.hpp" @@ -45,6 +46,11 @@ extern "C" delete[] buffer; } + char* quantum__rt__memory_allocate(uint64_t size) + { + return (char *)malloc((size_t)size); + } + // Fail the computation with the given error message. void quantum__rt__fail(QirString* msg) // NOLINT { diff --git a/src/QirRuntime/public/QirRuntime.hpp b/src/QirRuntime/public/QirRuntime.hpp index f8c601f1b79..563af6a2d50 100644 --- a/src/QirRuntime/public/QirRuntime.hpp +++ b/src/QirRuntime/public/QirRuntime.hpp @@ -61,6 +61,9 @@ extern "C" // Release a block of allocated heap memory. QIR_SHARED_API void quantum__rt__heap_free(char* buffer); // NOLINT + // Returns a pointer to the malloc-allocated block. + QIR_SHARED_API char* quantum__rt__memory_allocate(uint64_t size); // NOLINT + // Fail the computation with the given error message. QIR_SHARED_API void quantum__rt__fail(QirString* msg); // NOLINT From c8eec3d0eb36d871c44b18e1d9bbdc1735137226 Mon Sep 17 00:00:00 2001 From: "Stefan J. Wernli" Date: Thu, 18 Mar 2021 00:31:20 -0700 Subject: [PATCH 10/14] Update QIR scripts to latest compiler support --- AdvantageBenchmark/privateBuild/host.csproj | 2 +- .../releasedBuild/quantum/quantum.csproj | 2 +- Simulation.sln | 91 + src/QirRuntime/build-qir-runtime.ps1 | 36 +- .../qir-standalone-input-reference.ll | 66 +- .../qir-standalone-input-reference.csproj | 6 +- .../qir/qir-standalone-input-reference.ll | 89 + .../FullstateSimulator/qir-test-simulator.ll | 1855 ++++++++--------- .../qsharp/qir-test-simulator.csproj | 14 + .../{ => qsharp}/qir-test-simulator.qs | 30 +- .../qsharp/qir/qir-test-simulator.ll | 1367 ++++++++++++ .../test/QIR-dynamic/CMakeLists.txt | 12 +- ...-test-random-lnx.ll => qir-test-random.ll} | 172 +- .../QIR-dynamic/qsharp/qir-test-random.csproj | 14 + .../{ => qsharp}/qir-test-random.qs | 48 +- .../qir/qir-test-random.ll} | 172 +- .../test/QIR-static/qsharp/qir-gen.csproj | 2 +- src/QirRuntime/test/QIR-tracer/CMakeLists.txt | 12 +- .../qir/tracer-qir.ll} | 1609 +++++++------- .../{ => qsharp}/tracer-conditionals.qs | 48 +- .../QIR-tracer/{ => qsharp}/tracer-core.qs | 0 .../{ => qsharp}/tracer-intrinsics.qs | 0 .../test/QIR-tracer/qsharp/tracer-qir.csproj | 10 + .../QIR-tracer/{ => qsharp}/tracer-target.qs | 0 .../{tracer-qir-lnx.ll => tracer-qir.ll} | 1609 +++++++------- .../Microsoft.Quantum.CSharpGeneration.fsproj | 2 +- ....Simulation.QCTraceSimulatorRuntime.csproj | 2 +- .../Microsoft.Quantum.QSharp.Core.csproj | 2 +- ...Microsoft.Quantum.QSharp.Foundation.csproj | 2 +- .../HoneywellExe/HoneywellExe.csproj | 2 +- .../IntrinsicTests/IntrinsicTests.csproj | 2 +- .../TestProjects/IonQExe/IonQExe.csproj | 2 +- .../Library with Spaces.csproj | 2 +- .../TestProjects/Library1/Library1.csproj | 2 +- .../TestProjects/Library2/Library2.csproj | 2 +- .../TestProjects/QCIExe/QCIExe.csproj | 2 +- .../TestProjects/QSharpExe/QSharpExe.csproj | 2 +- .../TargetedExe/TargetedExe.csproj | 2 +- .../TestProjects/UnitTests/UnitTests.csproj | 2 +- .../Tests.Microsoft.Quantum.Simulators.csproj | 2 +- ....Microsoft.Quantum.Simulators.Type1.csproj | 2 +- ....Microsoft.Quantum.Simulators.Type2.csproj | 2 +- ....Microsoft.Quantum.Simulators.Type3.csproj | 2 +- .../Microsoft.Quantum.Simulators.csproj | 2 +- .../Microsoft.Quantum.Type1.Core.csproj | 2 +- .../Microsoft.Quantum.Type2.Core.csproj | 2 +- .../Microsoft.Quantum.Type3.Core.csproj | 2 +- 47 files changed, 4502 insertions(+), 2808 deletions(-) create mode 100644 src/QirRuntime/samples/StandaloneInputReference/qsharp/qir/qir-standalone-input-reference.ll create mode 100644 src/QirRuntime/test/FullstateSimulator/qsharp/qir-test-simulator.csproj rename src/QirRuntime/test/FullstateSimulator/{ => qsharp}/qir-test-simulator.qs (70%) create mode 100644 src/QirRuntime/test/FullstateSimulator/qsharp/qir/qir-test-simulator.ll rename src/QirRuntime/test/QIR-dynamic/{qir-test-random-lnx.ll => qir-test-random.ll} (75%) create mode 100644 src/QirRuntime/test/QIR-dynamic/qsharp/qir-test-random.csproj rename src/QirRuntime/test/QIR-dynamic/{ => qsharp}/qir-test-random.qs (96%) rename src/QirRuntime/test/QIR-dynamic/{qir-test-random-win.ll => qsharp/qir/qir-test-random.ll} (75%) rename src/QirRuntime/test/QIR-tracer/{tracer-qir-win.ll => qsharp/qir/tracer-qir.ll} (78%) rename src/QirRuntime/test/QIR-tracer/{ => qsharp}/tracer-conditionals.qs (97%) rename src/QirRuntime/test/QIR-tracer/{ => qsharp}/tracer-core.qs (100%) rename src/QirRuntime/test/QIR-tracer/{ => qsharp}/tracer-intrinsics.qs (100%) create mode 100644 src/QirRuntime/test/QIR-tracer/qsharp/tracer-qir.csproj rename src/QirRuntime/test/QIR-tracer/{ => qsharp}/tracer-target.qs (100%) rename src/QirRuntime/test/QIR-tracer/{tracer-qir-lnx.ll => tracer-qir.ll} (78%) diff --git a/AdvantageBenchmark/privateBuild/host.csproj b/AdvantageBenchmark/privateBuild/host.csproj index 945a912657b..ab801ea9a88 100644 --- a/AdvantageBenchmark/privateBuild/host.csproj +++ b/AdvantageBenchmark/privateBuild/host.csproj @@ -1,4 +1,4 @@ - + diff --git a/AdvantageBenchmark/releasedBuild/quantum/quantum.csproj b/AdvantageBenchmark/releasedBuild/quantum/quantum.csproj index edc2bedc0fb..3b308dec968 100644 --- a/AdvantageBenchmark/releasedBuild/quantum/quantum.csproj +++ b/AdvantageBenchmark/releasedBuild/quantum/quantum.csproj @@ -1,4 +1,4 @@ - + diff --git a/Simulation.sln b/Simulation.sln index d141c8b46c7..dc9f314bfcf 100644 --- a/Simulation.sln +++ b/Simulation.sln @@ -95,6 +95,24 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "QIR-static", "QIR-static", EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "qir-gen", "src\QirRuntime\test\QIR-static\qsharp\qir-gen.csproj", "{DC69B7C8-7B25-4C12-878A-DF59722C306E}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "FullstateSimulator", "FullstateSimulator", "{932E88FC-AB51-449D-937E-BB3050DF37C9}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "qir-test-simulator", "src\QirRuntime\test\FullstateSimulator\qsharp\qir-test-simulator.csproj", "{D529DE2B-C65B-4B89-82F3-FF712BC832BC}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "QIR-dynamic", "QIR-dynamic", "{E0DE8EF7-A587-4D02-8813-B344365E5CF8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "qir-test-random", "src\QirRuntime\test\QIR-dynamic\qsharp\qir-test-random.csproj", "{9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "QIR-tracer", "QIR-tracer", "{99C04F12-B449-4832-BFD6-FE5E91BAE393}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "tracer-qir", "src\QirRuntime\test\QIR-tracer\qsharp\tracer-qir.csproj", "{390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "samples", "samples", "{306E9DC4-15F6-4D98-8846-34EBBBC45CB0}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "StandaloneInputReference", "StandaloneInputReference", "{700A1D87-D0DE-4621-A6CD-3DC0AA47D492}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "qir-standalone-input-reference", "src\QirRuntime\samples\StandaloneInputReference\qsharp\qir-standalone-input-reference.csproj", "{91DF2E6D-65C1-478E-A276-337A40ADB1FB}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -667,6 +685,70 @@ Global {DC69B7C8-7B25-4C12-878A-DF59722C306E}.RelWithDebInfo|Any CPU.Build.0 = Debug|Any CPU {DC69B7C8-7B25-4C12-878A-DF59722C306E}.RelWithDebInfo|x64.ActiveCfg = Debug|Any CPU {DC69B7C8-7B25-4C12-878A-DF59722C306E}.RelWithDebInfo|x64.Build.0 = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.Debug|x64.ActiveCfg = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.Debug|x64.Build.0 = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.MinSizeRel|Any CPU.ActiveCfg = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.MinSizeRel|Any CPU.Build.0 = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.MinSizeRel|x64.ActiveCfg = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.MinSizeRel|x64.Build.0 = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.Release|Any CPU.Build.0 = Release|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.Release|x64.ActiveCfg = Release|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.Release|x64.Build.0 = Release|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.RelWithDebInfo|Any CPU.ActiveCfg = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.RelWithDebInfo|Any CPU.Build.0 = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.RelWithDebInfo|x64.ActiveCfg = Debug|Any CPU + {D529DE2B-C65B-4B89-82F3-FF712BC832BC}.RelWithDebInfo|x64.Build.0 = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.Debug|x64.ActiveCfg = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.Debug|x64.Build.0 = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.MinSizeRel|Any CPU.ActiveCfg = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.MinSizeRel|Any CPU.Build.0 = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.MinSizeRel|x64.ActiveCfg = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.MinSizeRel|x64.Build.0 = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.Release|Any CPU.Build.0 = Release|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.Release|x64.ActiveCfg = Release|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.Release|x64.Build.0 = Release|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.RelWithDebInfo|Any CPU.ActiveCfg = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.RelWithDebInfo|Any CPU.Build.0 = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.RelWithDebInfo|x64.ActiveCfg = Debug|Any CPU + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F}.RelWithDebInfo|x64.Build.0 = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.Debug|x64.ActiveCfg = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.Debug|x64.Build.0 = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.MinSizeRel|Any CPU.ActiveCfg = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.MinSizeRel|Any CPU.Build.0 = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.MinSizeRel|x64.ActiveCfg = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.MinSizeRel|x64.Build.0 = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.Release|Any CPU.Build.0 = Release|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.Release|x64.ActiveCfg = Release|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.Release|x64.Build.0 = Release|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.RelWithDebInfo|Any CPU.ActiveCfg = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.RelWithDebInfo|Any CPU.Build.0 = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.RelWithDebInfo|x64.ActiveCfg = Debug|Any CPU + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA}.RelWithDebInfo|x64.Build.0 = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.Debug|x64.ActiveCfg = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.Debug|x64.Build.0 = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.MinSizeRel|Any CPU.ActiveCfg = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.MinSizeRel|Any CPU.Build.0 = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.MinSizeRel|x64.ActiveCfg = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.MinSizeRel|x64.Build.0 = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.Release|Any CPU.Build.0 = Release|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.Release|x64.ActiveCfg = Release|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.Release|x64.Build.0 = Release|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.RelWithDebInfo|Any CPU.ActiveCfg = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.RelWithDebInfo|Any CPU.Build.0 = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.RelWithDebInfo|x64.ActiveCfg = Debug|Any CPU + {91DF2E6D-65C1-478E-A276-337A40ADB1FB}.RelWithDebInfo|x64.Build.0 = Debug|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -711,6 +793,15 @@ Global {E9FC86D7-DBE1-44B8-BF7F-61109E1AFE86} = {223F1FAE-5551-4237-AE8A-73502B007003} {9BED35A6-3FBF-4A55-8424-C801BEB64D68} = {E9FC86D7-DBE1-44B8-BF7F-61109E1AFE86} {DC69B7C8-7B25-4C12-878A-DF59722C306E} = {9BED35A6-3FBF-4A55-8424-C801BEB64D68} + {932E88FC-AB51-449D-937E-BB3050DF37C9} = {E9FC86D7-DBE1-44B8-BF7F-61109E1AFE86} + {D529DE2B-C65B-4B89-82F3-FF712BC832BC} = {932E88FC-AB51-449D-937E-BB3050DF37C9} + {E0DE8EF7-A587-4D02-8813-B344365E5CF8} = {E9FC86D7-DBE1-44B8-BF7F-61109E1AFE86} + {9FCFB543-A126-41DF-80A3-40A6AFBA4F4F} = {E0DE8EF7-A587-4D02-8813-B344365E5CF8} + {99C04F12-B449-4832-BFD6-FE5E91BAE393} = {E9FC86D7-DBE1-44B8-BF7F-61109E1AFE86} + {390608C0-35C4-4E81-8BF8-91F9EA9C1CDA} = {99C04F12-B449-4832-BFD6-FE5E91BAE393} + {306E9DC4-15F6-4D98-8846-34EBBBC45CB0} = {223F1FAE-5551-4237-AE8A-73502B007003} + {700A1D87-D0DE-4621-A6CD-3DC0AA47D492} = {306E9DC4-15F6-4D98-8846-34EBBBC45CB0} + {91DF2E6D-65C1-478E-A276-337A40ADB1FB} = {700A1D87-D0DE-4621-A6CD-3DC0AA47D492} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {929C0464-86D8-4F70-8835-0A5EAF930821} diff --git a/src/QirRuntime/build-qir-runtime.ps1 b/src/QirRuntime/build-qir-runtime.ps1 index e10c3dde683..c9ef084f33b 100644 --- a/src/QirRuntime/build-qir-runtime.ps1 +++ b/src/QirRuntime/build-qir-runtime.ps1 @@ -2,19 +2,33 @@ # Licensed under the MIT License. & (Join-Path $PSScriptRoot .. .. build set-env.ps1) -Write-Host "##[info]Compile Q# Projects into QIR" -$qirStaticPath = Join-Path $PSScriptRoot test QIR-static qsharp -if (!(Test-Path (Join-Path $qirStaticPath qir *.ll))) { - Write-Host "##[info]Build Q# project for QIR tests" - dotnet build $qirStaticPath -c $Env:BUILD_CONFIGURATION -v $Env:BUILD_VERBOSITY - if ($LastExitCode -ne 0) { - Write-Host "##vso[task.logissue type=error;]Failed to compile Q# project at '$qirStaticPath' into QIR." - throw "Failed to compile Q# project at '$qirStaticPath' into QIR." + +function Build-QirProject { + param ( + [string] + $FolderPath + ) + + if (!(Test-Path (Join-Path $FolderPath qir *.ll))) { + Write-Host "##[info]Build Q# project for QIR tests '$FolderPath'" + dotnet build $FolderPath -c $Env:BUILD_CONFIGURATION -v $Env:BUILD_VERBOSITY + if ($LastExitCode -ne 0) { + Write-Host "##vso[task.logissue type=error;]Failed to compile Q# project at '$FolderPath' into QIR." + throw "Failed to compile Q# project at '$FolderPath' into QIR." + } } + Copy-Item -Path (Join-Path $FolderPath qir *.ll) -Destination (Split-Path $FolderPath -Parent) + # Also copy to drops so it ends up in build artifacts, for easier post-build debugging. + Copy-Item -Path (Join-Path $FolderPath qir *.ll) -Destination $Env:DROPS_DIR } -Copy-Item -Path (Join-Path $qirStaticPath qir *.ll) -Destination (Split-Path $qirStaticPath -Parent) -# Also copy to drops so it ends up in build artifacts, for easier post-build debugging. -Copy-Item -Path (Join-Path $qirStaticPath qir *.ll) -Destination $Env:DROPS_DIR + +Write-Host "##[info]Compile Q# Projects into QIR" +Build-QirProject (Join-Path $PSScriptRoot test QIR-static qsharp) +Build-QirProject (Join-Path $PSScriptRoot test QIR-dynamic qsharp) +Build-QirProject (Join-Path $PSScriptRoot test QIR-tracer qsharp) +Build-QirProject (Join-Path $PSScriptRoot test FullstateSimulator qsharp) +Build-QirProject (Join-Path $PSScriptRoot samples StandaloneInputReference qsharp) + Write-Host "##[info]Build QIR Runtime" $oldCC = $env:CC diff --git a/src/QirRuntime/samples/StandaloneInputReference/qir-standalone-input-reference.ll b/src/QirRuntime/samples/StandaloneInputReference/qir-standalone-input-reference.ll index d990f34df62..29f506d0d40 100644 --- a/src/QirRuntime/samples/StandaloneInputReference/qir-standalone-input-reference.ll +++ b/src/QirRuntime/samples/StandaloneInputReference/qir-standalone-input-reference.ll @@ -1,10 +1,8 @@ -%Result = type opaque %Range = type { i64, i64, i64 } +%Result = type opaque %String = type opaque -@ResultZero = external global %Result* -@ResultOne = external global %Result* @PauliI = constant i2 0 @PauliX = constant i2 1 @PauliY = constant i2 -1 @@ -16,49 +14,47 @@ @3 = internal constant [14 x i8] c"resultValue: \00" @4 = internal constant [14 x i8] c"stringValue: \00" -@Quantum__StandaloneSupportedInputs__ExerciseInputs = alias i64 (i64, double, %Result*, %String*), i64 (i64, double, %Result*, %String*)* @Quantum__StandaloneSupportedInputs__ExerciseInputs__body - -define i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs__body(i64 %intValue, double %doubleValue, %Result* %resultValue, %String* %stringValue) #0 { +define i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs__body(i64 %intValue, double %doubleValue, %Result* %resultValue, %String* %stringValue) { entry: - %msg = call %String* @__quantum__rt__string_create(i32 25, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @0, i32 0, i32 0)) + %msg = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @0, i32 0, i32 0)) call void @__quantum__qis__message__body(%String* %msg) - call void @__quantum__rt__string_update_reference_count(%String* %msg, i64 -1) - %0 = call %String* @__quantum__rt__string_create(i32 10, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @1, i32 0, i32 0)) + call void @__quantum__rt__string_update_reference_count(%String* %msg, i32 -1) + %0 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @1, i32 0, i32 0)) %1 = call %String* @__quantum__rt__int_to_string(i64 %intValue) %msg__1 = call %String* @__quantum__rt__string_concatenate(%String* %0, %String* %1) - call void @__quantum__rt__string_update_reference_count(%String* %0, i64 -1) - call void @__quantum__rt__string_update_reference_count(%String* %1, i64 -1) + call void @__quantum__rt__string_update_reference_count(%String* %0, i32 -1) + call void @__quantum__rt__string_update_reference_count(%String* %1, i32 -1) call void @__quantum__qis__message__body(%String* %msg__1) - call void @__quantum__rt__string_update_reference_count(%String* %msg__1, i64 -1) - %2 = call %String* @__quantum__rt__string_create(i32 13, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @2, i32 0, i32 0)) + call void @__quantum__rt__string_update_reference_count(%String* %msg__1, i32 -1) + %2 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @2, i32 0, i32 0)) %3 = call %String* @__quantum__rt__double_to_string(double %doubleValue) %msg__2 = call %String* @__quantum__rt__string_concatenate(%String* %2, %String* %3) - call void @__quantum__rt__string_update_reference_count(%String* %2, i64 -1) - call void @__quantum__rt__string_update_reference_count(%String* %3, i64 -1) + call void @__quantum__rt__string_update_reference_count(%String* %2, i32 -1) + call void @__quantum__rt__string_update_reference_count(%String* %3, i32 -1) call void @__quantum__qis__message__body(%String* %msg__2) - call void @__quantum__rt__string_update_reference_count(%String* %msg__2, i64 -1) - %4 = call %String* @__quantum__rt__string_create(i32 13, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @3, i32 0, i32 0)) + call void @__quantum__rt__string_update_reference_count(%String* %msg__2, i32 -1) + %4 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @3, i32 0, i32 0)) %5 = call %String* @__quantum__rt__result_to_string(%Result* %resultValue) %msg__3 = call %String* @__quantum__rt__string_concatenate(%String* %4, %String* %5) - call void @__quantum__rt__string_update_reference_count(%String* %4, i64 -1) - call void @__quantum__rt__string_update_reference_count(%String* %5, i64 -1) + call void @__quantum__rt__string_update_reference_count(%String* %4, i32 -1) + call void @__quantum__rt__string_update_reference_count(%String* %5, i32 -1) call void @__quantum__qis__message__body(%String* %msg__3) - call void @__quantum__rt__string_update_reference_count(%String* %msg__3, i64 -1) - %6 = call %String* @__quantum__rt__string_create(i32 13, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @4, i32 0, i32 0)) - call void @__quantum__rt__string_update_reference_count(%String* %stringValue, i64 1) + call void @__quantum__rt__string_update_reference_count(%String* %msg__3, i32 -1) + %6 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @4, i32 0, i32 0)) + call void @__quantum__rt__string_update_reference_count(%String* %stringValue, i32 1) %msg__4 = call %String* @__quantum__rt__string_concatenate(%String* %6, %String* %stringValue) - call void @__quantum__rt__string_update_reference_count(%String* %6, i64 -1) - call void @__quantum__rt__string_update_reference_count(%String* %stringValue, i64 -1) + call void @__quantum__rt__string_update_reference_count(%String* %6, i32 -1) + call void @__quantum__rt__string_update_reference_count(%String* %stringValue, i32 -1) call void @__quantum__qis__message__body(%String* %msg__4) - call void @__quantum__rt__string_update_reference_count(%String* %msg__4, i64 -1) + call void @__quantum__rt__string_update_reference_count(%String* %msg__4, i32 -1) ret i64 0 } -declare %String* @__quantum__rt__string_create(i32, i8*) +declare %String* @__quantum__rt__string_create(i8*) declare void @__quantum__qis__message__body(%String*) -declare void @__quantum__rt__string_update_reference_count(%String*, i64) +declare void @__quantum__rt__string_update_reference_count(%String*, i32) declare %String* @__quantum__rt__int_to_string(i64) @@ -74,4 +70,20 @@ entry: ret void } +define i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs(i64 %intValue, double %doubleValue, i8 %resultValue, i8* %stringValue) #0 { +entry: + %0 = icmp eq i8 %resultValue, 0 + %1 = call %Result* @__quantum__rt__result_get_zero() + %2 = call %Result* @__quantum__rt__result_get_one() + %3 = select i1 %0, %Result* %1, %Result* %2 + %4 = call %String* @__quantum__rt__string_create(i8* %stringValue) + %5 = call i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs__body(i64 %intValue, double %doubleValue, %Result* %3, %String* %4) + call void @__quantum__rt__string_update_reference_count(%String* %4, i32 -1) + ret i64 %5 +} + +declare %Result* @__quantum__rt__result_get_zero() + +declare %Result* @__quantum__rt__result_get_one() + attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/samples/StandaloneInputReference/qsharp/qir-standalone-input-reference.csproj b/src/QirRuntime/samples/StandaloneInputReference/qsharp/qir-standalone-input-reference.csproj index 5878e9774c3..74ef21518f7 100644 --- a/src/QirRuntime/samples/StandaloneInputReference/qsharp/qir-standalone-input-reference.csproj +++ b/src/QirRuntime/samples/StandaloneInputReference/qsharp/qir-standalone-input-reference.csproj @@ -1,4 +1,4 @@ - + Exe @@ -6,4 +6,8 @@ True + + + + diff --git a/src/QirRuntime/samples/StandaloneInputReference/qsharp/qir/qir-standalone-input-reference.ll b/src/QirRuntime/samples/StandaloneInputReference/qsharp/qir/qir-standalone-input-reference.ll new file mode 100644 index 00000000000..29f506d0d40 --- /dev/null +++ b/src/QirRuntime/samples/StandaloneInputReference/qsharp/qir/qir-standalone-input-reference.ll @@ -0,0 +1,89 @@ + +%Range = type { i64, i64, i64 } +%Result = type opaque +%String = type opaque + +@PauliI = constant i2 0 +@PauliX = constant i2 1 +@PauliY = constant i2 -1 +@PauliZ = constant i2 -2 +@EmptyRange = internal constant %Range { i64 0, i64 1, i64 -1 } +@0 = internal constant [26 x i8] c"Exercise Supported Inputs\00" +@1 = internal constant [11 x i8] c"intValue: \00" +@2 = internal constant [14 x i8] c"doubleValue: \00" +@3 = internal constant [14 x i8] c"resultValue: \00" +@4 = internal constant [14 x i8] c"stringValue: \00" + +define i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs__body(i64 %intValue, double %doubleValue, %Result* %resultValue, %String* %stringValue) { +entry: + %msg = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @0, i32 0, i32 0)) + call void @__quantum__qis__message__body(%String* %msg) + call void @__quantum__rt__string_update_reference_count(%String* %msg, i32 -1) + %0 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @1, i32 0, i32 0)) + %1 = call %String* @__quantum__rt__int_to_string(i64 %intValue) + %msg__1 = call %String* @__quantum__rt__string_concatenate(%String* %0, %String* %1) + call void @__quantum__rt__string_update_reference_count(%String* %0, i32 -1) + call void @__quantum__rt__string_update_reference_count(%String* %1, i32 -1) + call void @__quantum__qis__message__body(%String* %msg__1) + call void @__quantum__rt__string_update_reference_count(%String* %msg__1, i32 -1) + %2 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @2, i32 0, i32 0)) + %3 = call %String* @__quantum__rt__double_to_string(double %doubleValue) + %msg__2 = call %String* @__quantum__rt__string_concatenate(%String* %2, %String* %3) + call void @__quantum__rt__string_update_reference_count(%String* %2, i32 -1) + call void @__quantum__rt__string_update_reference_count(%String* %3, i32 -1) + call void @__quantum__qis__message__body(%String* %msg__2) + call void @__quantum__rt__string_update_reference_count(%String* %msg__2, i32 -1) + %4 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @3, i32 0, i32 0)) + %5 = call %String* @__quantum__rt__result_to_string(%Result* %resultValue) + %msg__3 = call %String* @__quantum__rt__string_concatenate(%String* %4, %String* %5) + call void @__quantum__rt__string_update_reference_count(%String* %4, i32 -1) + call void @__quantum__rt__string_update_reference_count(%String* %5, i32 -1) + call void @__quantum__qis__message__body(%String* %msg__3) + call void @__quantum__rt__string_update_reference_count(%String* %msg__3, i32 -1) + %6 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @4, i32 0, i32 0)) + call void @__quantum__rt__string_update_reference_count(%String* %stringValue, i32 1) + %msg__4 = call %String* @__quantum__rt__string_concatenate(%String* %6, %String* %stringValue) + call void @__quantum__rt__string_update_reference_count(%String* %6, i32 -1) + call void @__quantum__rt__string_update_reference_count(%String* %stringValue, i32 -1) + call void @__quantum__qis__message__body(%String* %msg__4) + call void @__quantum__rt__string_update_reference_count(%String* %msg__4, i32 -1) + ret i64 0 +} + +declare %String* @__quantum__rt__string_create(i8*) + +declare void @__quantum__qis__message__body(%String*) + +declare void @__quantum__rt__string_update_reference_count(%String*, i32) + +declare %String* @__quantum__rt__int_to_string(i64) + +declare %String* @__quantum__rt__string_concatenate(%String*, %String*) + +declare %String* @__quantum__rt__double_to_string(double) + +declare %String* @__quantum__rt__result_to_string(%Result*) + +define void @Microsoft__Quantum__Intrinsic__Message__body(%String* %msg) { +entry: + call void @__quantum__qis__message__body(%String* %msg) + ret void +} + +define i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs(i64 %intValue, double %doubleValue, i8 %resultValue, i8* %stringValue) #0 { +entry: + %0 = icmp eq i8 %resultValue, 0 + %1 = call %Result* @__quantum__rt__result_get_zero() + %2 = call %Result* @__quantum__rt__result_get_one() + %3 = select i1 %0, %Result* %1, %Result* %2 + %4 = call %String* @__quantum__rt__string_create(i8* %stringValue) + %5 = call i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs__body(i64 %intValue, double %doubleValue, %Result* %3, %String* %4) + call void @__quantum__rt__string_update_reference_count(%String* %4, i32 -1) + ret i64 %5 +} + +declare %Result* @__quantum__rt__result_get_zero() + +declare %Result* @__quantum__rt__result_get_one() + +attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/test/FullstateSimulator/qir-test-simulator.ll b/src/QirRuntime/test/FullstateSimulator/qir-test-simulator.ll index dd0bebfe9a1..fd09ccb8cb8 100644 --- a/src/QirRuntime/test/FullstateSimulator/qir-test-simulator.ll +++ b/src/QirRuntime/test/FullstateSimulator/qir-test-simulator.ll @@ -1,13 +1,11 @@ -%Result = type opaque %Range = type { i64, i64, i64 } %Tuple = type opaque +%Callable = type opaque %Qubit = type opaque %Array = type opaque -%Callable = type opaque +%Result = type opaque -@ResultZero = external global %Result* -@ResultOne = external global %Result* @PauliI = constant i2 0 @PauliX = constant i2 1 @PauliY = constant i2 -1 @@ -21,530 +19,171 @@ @Microsoft__Quantum__Intrinsic__T = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__ctladj__wrapper] @Microsoft__Quantum__Intrinsic__R = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__ctladj__wrapper] @PartialApplication__1 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__ctladj__wrapper] -@MemoryManagement__1 = constant [2 x void (%Tuple*, i64)*] [void (%Tuple*, i64)* @MemoryManagement__1__RefCount, void (%Tuple*, i64)* @MemoryManagement__1__AliasCount] +@MemoryManagement__1 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__1__RefCount, void (%Tuple*, i32)* @MemoryManagement__1__AliasCount] @Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS = alias i64 (), i64 ()* @Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS__body -define void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__x__body(%Qubit* %qb) - ret void -} - -declare void @__quantum__qis__x__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__x__body(%Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__x__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -declare void @__quantum__rt__array_update_alias_count(%Array*, i64) - -declare void @__quantum__qis__x__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__x__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qb) { -entry: - %bases__inline__1 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases__inline__1, i64 0) - %1 = bitcast i8* %0 to i2* - %2 = load i2, i2* @PauliZ - store i2 %2, i2* %1 - call void @__quantum__rt__array_update_alias_count(%Array* %bases__inline__1, i64 1) - %qubits__inline__1 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %3 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits__inline__1, i64 0) - %4 = bitcast i8* %3 to %Qubit** - store %Qubit* %qb, %Qubit** %4 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits__inline__1, i64 1) - %5 = call %Result* @__quantum__qis__measure__body(%Array* %bases__inline__1, %Array* %qubits__inline__1) - call void @__quantum__rt__array_update_alias_count(%Array* %bases__inline__1, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits__inline__1, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %bases__inline__1, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qubits__inline__1, i64 -1) - ret %Result* %5 -} - -declare %Array* @__quantum__rt__array_create_1d(i32, i64) - -declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) - -declare %Result* @__quantum__qis__measure__body(%Array*, %Array*) - -declare void @__quantum__rt__array_update_reference_count(%Array*, i64) - -define void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__s__body(%Qubit* %qb) - ret void -} - -declare void @__quantum__qis__s__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__s__adj(%Qubit* %qb) - ret void -} - -declare void @__quantum__qis__s__adj(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__s__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -declare void @__quantum__qis__s__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__s__ctladj(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -declare void @__quantum__qis__s__ctladj(%Array*, %Qubit*) - -define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %bases, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret %Result* %0 -} - -define void @Microsoft__Quantum__Intrinsic__T__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__t__body(%Qubit* %qb) - ret void -} - -declare void @__quantum__qis__t__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__T__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__t__adj(%Qubit* %qb) - ret void -} - -declare void @__quantum__qis__t__adj(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__t__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -declare void @__quantum__qis__t__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__t__ctladj(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -declare void @__quantum__qis__t__ctladj(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qb) - ret void -} - -declare void @__quantum__qis__h__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -declare void @__quantum__qis__h__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__y__body(%Qubit* %qb) - ret void -} - -declare void @__quantum__qis__y__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__y__body(%Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__y__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -declare void @__quantum__qis__y__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__y__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__R__body(i2 %pauli, double %theta, %Qubit* %qubit) { -entry: - call void @__quantum__qis__r__body(i2 %pauli, double %theta, %Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__r__body(i2, double, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__R__adj(i2 %pauli, double %theta, %Qubit* %qubit) { -entry: - call void @__quantum__qis__r__adj(i2 %pauli, double %theta, %Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__r__adj(i2, double, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__R__ctl(%Array* %__controlQubits__, { i2, double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - %1 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 0 - %pauli = load i2, i2* %1 - %2 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 1 - %theta = load double, double* %2 - %3 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 2 - %qubit = load %Qubit*, %Qubit** %3 - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { i2, double, %Qubit* }* - %6 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i64 0, i32 0 - %7 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i64 0, i32 1 - %8 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i64 0, i32 2 - store i2 %pauli, i2* %6 - store double %theta, double* %7 - store %Qubit* %qubit, %Qubit** %8 - call void @__quantum__qis__r__ctl(%Array* %__controlQubits__, { i2, double, %Qubit* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i64 -1) - ret void -} - -declare void @__quantum__qis__r__ctl(%Array*, { i2, double, %Qubit* }*) - -declare %Tuple* @__quantum__rt__tuple_create(i64) - -declare void @__quantum__rt__tuple_update_reference_count(%Tuple*, i64) - -define void @Microsoft__Quantum__Intrinsic__R__ctladj(%Array* %__controlQubits__, { i2, double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - %1 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 0 - %pauli = load i2, i2* %1 - %2 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 1 - %theta = load double, double* %2 - %3 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 2 - %qubit = load %Qubit*, %Qubit** %3 - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { i2, double, %Qubit* }* - %6 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i64 0, i32 0 - %7 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i64 0, i32 1 - %8 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i64 0, i32 2 - store i2 %pauli, i2* %6 - store double %theta, double* %7 - store %Qubit* %qubit, %Qubit** %8 - call void @__quantum__qis__r__ctladj(%Array* %__controlQubits__, { i2, double, %Qubit* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i64 -1) - ret void -} - -declare void @__quantum__qis__r__ctladj(%Array*, { i2, double, %Qubit* }*) - -define void @Microsoft__Quantum__Intrinsic__Exp__body(%Array* %paulis, double %theta, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - call void @__quantum__qis__exp__body(%Array* %paulis, double %theta, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret void -} - -declare void @__quantum__qis__exp__body(%Array*, double, %Array*) - -define void @Microsoft__Quantum__Intrinsic__Exp__adj(%Array* %paulis, double %theta, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - call void @__quantum__qis__exp__adj(%Array* %paulis, double %theta, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret void -} - -declare void @__quantum__qis__exp__adj(%Array*, double, %Array*) - -define void @Microsoft__Quantum__Intrinsic__Exp__ctl(%Array* %__controlQubits__, { %Array*, double, %Array* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - %1 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i64 0, i32 0 - %paulis = load %Array*, %Array** %1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 1) - %2 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i64 0, i32 1 - %theta = load double, double* %2 - %3 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i64 0, i32 2 - %qubits = load %Array*, %Array** %3 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { %Array*, double, %Array* }* - %6 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i64 0, i32 0 - %7 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i64 0, i32 1 - %8 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i64 0, i32 2 - store %Array* %paulis, %Array** %6 - store double %theta, double* %7 - store %Array* %qubits, %Array** %8 - call void @__quantum__qis__exp__ctl(%Array* %__controlQubits__, { %Array*, double, %Array* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i64 -1) - ret void -} - -declare void @__quantum__qis__exp__ctl(%Array*, { %Array*, double, %Array* }*) - -define void @Microsoft__Quantum__Intrinsic__Exp__ctladj(%Array* %__controlQubits__, { %Array*, double, %Array* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - %1 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i64 0, i32 0 - %paulis = load %Array*, %Array** %1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 1) - %2 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i64 0, i32 1 - %theta = load double, double* %2 - %3 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i64 0, i32 2 - %qubits = load %Array*, %Array** %3 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { %Array*, double, %Array* }* - %6 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i64 0, i32 0 - %7 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i64 0, i32 1 - %8 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i64 0, i32 2 - store %Array* %paulis, %Array** %6 - store double %theta, double* %7 - store %Array* %qubits, %Array** %8 - call void @__quantum__qis__exp__ctladj(%Array* %__controlQubits__, { %Array*, double, %Array* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i64 -1) - ret void -} - -declare void @__quantum__qis__exp__ctladj(%Array*, { %Array*, double, %Array* }*) - -define void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__z__body(%Qubit* %qb) - ret void -} - -declare void @__quantum__qis__z__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__z__body(%Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__z__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -declare void @__quantum__qis__z__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__z__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - define i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %op) { entry: - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %op, i64 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i64 1) - %res = alloca i64 - store i64 0, i64* %res + call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 1) + %res = alloca i64, align 8 + store i64 0, i64* %res, align 4 %target = call %Qubit* @__quantum__rt__qubit_allocate() %ctls = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) %1 = bitcast %Tuple* %0 to { %Qubit* }* - %2 = getelementptr { %Qubit* }, { %Qubit* }* %1, i64 0, i32 0 - store %Qubit* %target, %Qubit** %2 + %2 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %1, i32 0, i32 0 + store %Qubit* %target, %Qubit** %2, align 8 call void @__quantum__rt__callable_invoke(%Callable* %op, %Tuple* %0, %Tuple* null) %3 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %3, i64 1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 1) call void @__quantum__rt__callable_make_adjoint(%Callable* %3) %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) %5 = bitcast %Tuple* %4 to { %Qubit* }* - %6 = getelementptr { %Qubit* }, { %Qubit* }* %5, i64 0, i32 0 - store %Qubit* %target, %Qubit** %6 + %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 + store %Qubit* %target, %Qubit** %6, align 8 call void @__quantum__rt__callable_invoke(%Callable* %3, %Tuple* %4, %Tuple* null) %7 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %target) - %8 = load %Result*, %Result** @ResultZero + %8 = call %Result* @__quantum__rt__result_get_zero() %9 = call i1 @__quantum__rt__result_equal(%Result* %7, %Result* %8) %10 = xor i1 %9, true br i1 %10, label %then0__1, label %else__1 then0__1: ; preds = %entry - store i64 1, i64* %res + store i64 1, i64* %res, align 4 br label %continue__1 else__1: ; preds = %entry %11 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) %12 = bitcast i8* %11 to %Qubit** - %qb__inline__1 = load %Qubit*, %Qubit** %12 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__1) + %qubit = load %Qubit*, %Qubit** %12, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit) %13 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) %14 = bitcast i8* %13 to %Qubit** - %qb__inline__2 = load %Qubit*, %Qubit** %14 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__2) + %qubit__1 = load %Qubit*, %Qubit** %14, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__1) %15 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %15, i64 1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 1) call void @__quantum__rt__callable_make_controlled(%Callable* %15) %16 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) %17 = bitcast %Tuple* %16 to { %Array*, %Qubit* }* - %18 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %17, i64 0, i32 0 - %19 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %17, i64 0, i32 1 - store %Array* %ctls, %Array** %18 - store %Qubit* %target, %Qubit** %19 + %18 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %17, i32 0, i32 0 + %19 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %17, i32 0, i32 1 + store %Array* %ctls, %Array** %18, align 8 + store %Qubit* %target, %Qubit** %19, align 8 call void @__quantum__rt__callable_invoke(%Callable* %15, %Tuple* %16, %Tuple* null) %20 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %20, i64 1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %20, i32 1) call void @__quantum__rt__callable_make_controlled(%Callable* %20) call void @__quantum__rt__callable_make_adjoint(%Callable* %20) %21 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) %22 = bitcast %Tuple* %21 to { %Array*, %Qubit* }* - %23 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %22, i64 0, i32 0 - %24 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %22, i64 0, i32 1 - store %Array* %ctls, %Array** %23 - store %Qubit* %target, %Qubit** %24 + %23 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %22, i32 0, i32 0 + %24 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %22, i32 0, i32 1 + store %Array* %ctls, %Array** %23, align 8 + store %Qubit* %target, %Qubit** %24, align 8 call void @__quantum__rt__callable_invoke(%Callable* %20, %Tuple* %21, %Tuple* null) %25 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %target) - %26 = load %Result*, %Result** @ResultZero + %26 = call %Result* @__quantum__rt__result_get_zero() %27 = call i1 @__quantum__rt__result_equal(%Result* %25, %Result* %26) %28 = xor i1 %27, true br i1 %28, label %then0__2, label %continue__2 then0__2: ; preds = %else__1 - store i64 2, i64* %res + store i64 2, i64* %res, align 4 br label %continue__2 continue__2: ; preds = %then0__2, %else__1 %29 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) %30 = bitcast i8* %29 to %Qubit** - %qb__inline__3 = load %Qubit*, %Qubit** %30 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__3) + %qubit__2 = load %Qubit*, %Qubit** %30, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__2) %31 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) %32 = bitcast i8* %31 to %Qubit** - %qb__inline__4 = load %Qubit*, %Qubit** %32 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__4) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %15, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %16, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %20, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %20, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %21, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %25, i64 -1) + %qubit__3 = load %Qubit*, %Qubit** %32, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__3) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %16, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %20, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %20, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %21, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %25, i32 -1) br label %continue__1 continue__1: ; preds = %continue__2, %then0__1 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %7, i32 -1) call void @__quantum__rt__qubit_release(%Qubit* %target) call void @__quantum__rt__qubit_release_array(%Array* %ctls) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %0, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %3, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %7, i64 -1) - %33 = load i64, i64* %res - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %op, i64 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i64 -1) + %33 = load i64, i64* %res, align 4 + call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 -1) ret i64 %33 } -declare void @__quantum__rt__callable_memory_management(i32, %Callable*, i64) +declare void @__quantum__rt__capture_update_alias_count(%Callable*, i32) -declare void @__quantum__rt__callable_update_alias_count(%Callable*, i64) +declare void @__quantum__rt__callable_update_alias_count(%Callable*, i32) declare %Qubit* @__quantum__rt__qubit_allocate() declare %Array* @__quantum__rt__qubit_allocate_array(i64) +declare void @__quantum__rt__array_update_alias_count(%Array*, i32) + declare void @__quantum__rt__callable_invoke(%Callable*, %Tuple*, %Tuple*) +declare %Tuple* @__quantum__rt__tuple_create(i64) + declare %Callable* @__quantum__rt__callable_copy(%Callable*, i1) +declare void @__quantum__rt__capture_update_reference_count(%Callable*, i32) + declare void @__quantum__rt__callable_make_adjoint(%Callable*) +define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qubit) { +entry: + %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 1) + %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) + %1 = bitcast i8* %0 to i2* + %2 = load i2, i2* @PauliZ, align 1 + store i2 %2, i2* %1, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) + %qubits = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) + %3 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) + %4 = bitcast i8* %3 to %Qubit** + store %Qubit* %qubit, %Qubit** %4, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %5 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %qubits, i32 -1) + ret %Result* %5 +} + +declare %Result* @__quantum__rt__result_get_zero() + declare i1 @__quantum__rt__result_equal(%Result*, %Result*) +declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) + +declare void @__quantum__qis__h__body(%Qubit*) + declare void @__quantum__rt__callable_make_controlled(%Callable*) -declare void @__quantum__rt__callable_update_reference_count(%Callable*, i64) +declare void @__quantum__rt__callable_update_reference_count(%Callable*, i32) + +declare void @__quantum__rt__tuple_update_reference_count(%Tuple*, i32) -declare void @__quantum__rt__result_update_reference_count(%Result*, i64) +declare void @__quantum__rt__result_update_reference_count(%Result*, i32) declare void @__quantum__rt__qubit_release(%Qubit*) @@ -552,406 +191,374 @@ declare void @__quantum__rt__qubit_release_array(%Array*) define i64 @Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS__body() #0 { entry: - %res = alloca i64 - store i64 0, i64* %res - %0 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__X, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %res = alloca i64, align 8 + store i64 0, i64* %res, align 4 + %0 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__X, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %1 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %0) - store i64 %1, i64* %res + store i64 %1, i64* %res, align 4 %2 = icmp ne i64 %1, 0 br i1 %2, label %then0__1, label %continue__1 then0__1: ; preds = %entry - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %0, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i64 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) ret i64 %1 continue__1: ; preds = %entry - %3 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Y, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %3 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Y, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %4 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %3) - store i64 %4, i64* %res + store i64 %4, i64* %res, align 4 %5 = icmp ne i64 %4, 0 br i1 %5, label %then0__2, label %continue__2 then0__2: ; preds = %continue__1 %6 = add i64 10, %4 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %0, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %3, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i64 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) ret i64 %6 continue__2: ; preds = %continue__1 - %7 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Z, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %7 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Z, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %8 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %7) - store i64 %8, i64* %res + store i64 %8, i64* %res, align 4 %9 = icmp ne i64 %8, 0 br i1 %9, label %then0__3, label %continue__3 then0__3: ; preds = %continue__2 %10 = add i64 20, %8 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %0, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %3, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %7, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i64 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) ret i64 %10 continue__3: ; preds = %continue__2 - %11 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__H, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %11 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__H, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %12 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %11) - store i64 %12, i64* %res + store i64 %12, i64* %res, align 4 %13 = icmp ne i64 %12, 0 br i1 %13, label %then0__4, label %continue__4 then0__4: ; preds = %continue__3 %14 = add i64 30, %12 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %0, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %3, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %7, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %11, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i64 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) ret i64 %14 continue__4: ; preds = %continue__3 - %15 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__S, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %15 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__S, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %16 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %15) - store i64 %16, i64* %res + store i64 %16, i64* %res, align 4 %17 = icmp ne i64 %16, 0 br i1 %17, label %then0__5, label %continue__5 then0__5: ; preds = %continue__4 %18 = add i64 40, %16 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %0, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %3, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %7, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %11, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %15, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i64 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) ret i64 %18 continue__5: ; preds = %continue__4 - %19 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__T, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %19 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__T, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %20 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %19) - store i64 %20, i64* %res + store i64 %20, i64* %res, align 4 %21 = icmp ne i64 %20, 0 br i1 %21, label %then0__6, label %continue__6 then0__6: ; preds = %continue__5 %22 = add i64 50, %20 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %0, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %3, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %7, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %11, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %15, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %19, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i64 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) ret i64 %22 continue__6: ; preds = %continue__5 %23 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Callable*, i2, double }* getelementptr ({ %Callable*, i2, double }, { %Callable*, i2, double }* null, i32 1) to i64)) %24 = bitcast %Tuple* %23 to { %Callable*, i2, double }* - %25 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i64 0, i32 0 - %26 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i64 0, i32 1 - %27 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i64 0, i32 2 - %28 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__R, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) - %29 = load i2, i2* @PauliX - store %Callable* %28, %Callable** %25 - store i2 %29, i2* %26 - store double 4.200000e-01, double* %27 - %30 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__1, [2 x void (%Tuple*, i64)*]* @MemoryManagement__1, %Tuple* %23) + %25 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 0 + %26 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 1 + %27 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 2 + %28 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__R, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %29 = load i2, i2* @PauliX, align 1 + store %Callable* %28, %Callable** %25, align 8 + store i2 %29, i2* %26, align 1 + store double 4.200000e-01, double* %27, align 8 + %30 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__1, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %23) %31 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %30) - store i64 %31, i64* %res + store i64 %31, i64* %res, align 4 %32 = icmp ne i64 %31, 0 br i1 %32, label %then0__7, label %continue__7 then0__7: ; preds = %continue__6 %33 = add i64 60, %31 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %0, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %3, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %7, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %11, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %15, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %19, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %30, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i64 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) ret i64 %33 continue__7: ; preds = %continue__6 %targets = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) %ctls = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - %paulis__inline__1 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %34 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__inline__1, i64 0) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + %paulis = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) + %34 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %35 = bitcast i8* %34 to i2* - %36 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__inline__1, i64 1) + %36 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %37 = bitcast i8* %36 to i2* - %38 = load i2, i2* @PauliX - %39 = load i2, i2* @PauliY - store i2 %38, i2* %35 - store i2 %39, i2* %37 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__inline__1, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i64 1) - call void @__quantum__qis__exp__body(%Array* %paulis__inline__1, double 4.200000e-01, %Array* %targets) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__inline__1, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis__inline__1, i64 -1) - %paulis__inline__2 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__inline__2, i64 0) + %38 = load i2, i2* @PauliX, align 1 + %39 = load i2, i2* @PauliY, align 1 + store i2 %38, i2* %35, align 1 + store i2 %39, i2* %37, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) + call void @__quantum__qis__exp__body(%Array* %paulis, double 4.200000e-01, %Array* %targets) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %paulis, i32 -1) + %paulis__1 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) + %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__1, i64 0) %41 = bitcast i8* %40 to i2* - %42 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__inline__2, i64 1) + %42 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__1, i64 1) %43 = bitcast i8* %42 to i2* - %44 = load i2, i2* @PauliX - %45 = load i2, i2* @PauliY - store i2 %44, i2* %41 - store i2 %45, i2* %43 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__inline__2, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i64 1) - call void @__quantum__qis__exp__adj(%Array* %paulis__inline__2, double 4.200000e-01, %Array* %targets) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__inline__2, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis__inline__2, i64 -1) + %44 = load i2, i2* @PauliX, align 1 + %45 = load i2, i2* @PauliY, align 1 + store i2 %44, i2* %41, align 1 + store i2 %45, i2* %43, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__1, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) + call void @__quantum__qis__exp__adj(%Array* %paulis__1, double 4.200000e-01, %Array* %targets) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__1, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %paulis__1, i32 -1) %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %targets, i64 0) %47 = bitcast i8* %46 to %Qubit** - %48 = load %Qubit*, %Qubit** %47 + %48 = load %Qubit*, %Qubit** %47, align 8 %49 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %48) - %50 = load %Result*, %Result** @ResultZero + %50 = call %Result* @__quantum__rt__result_get_zero() %51 = call i1 @__quantum__rt__result_equal(%Result* %49, %Result* %50) %52 = xor i1 %51, true - %53 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %targets, i64 1) - %54 = bitcast i8* %53 to %Qubit** - %55 = load %Qubit*, %Qubit** %54 - %56 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %55) - %57 = load %Result*, %Result** @ResultZero - %58 = call i1 @__quantum__rt__result_equal(%Result* %56, %Result* %57) - %59 = xor i1 %58, true - %60 = or i1 %52, %59 - br i1 %60, label %then0__8, label %else__1 + br i1 %52, label %then0__8, label %continue__8 then0__8: ; preds = %continue__7 - store i64 1, i64* %res + store i64 1, i64* %res, align 4 br label %continue__8 -else__1: ; preds = %continue__7 - %61 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %62 = bitcast i8* %61 to %Qubit** - %qb__inline__3 = load %Qubit*, %Qubit** %62 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__3) - %63 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) - %64 = bitcast i8* %63 to %Qubit** - %qb__inline__4 = load %Qubit*, %Qubit** %64 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__4) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - %paulis__inline__5 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %65 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__inline__5, i64 0) - %66 = bitcast i8* %65 to i2* - %67 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__inline__5, i64 1) - %68 = bitcast i8* %67 to i2* - %69 = load i2, i2* @PauliX - %70 = load i2, i2* @PauliY - store i2 %69, i2* %66 - store i2 %70, i2* %68 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__inline__5, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i64 1) - %71 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %72 = bitcast %Tuple* %71 to { %Array*, double, %Array* }* - %73 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %72, i64 0, i32 0 - %74 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %72, i64 0, i32 1 - %75 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %72, i64 0, i32 2 - store %Array* %paulis__inline__5, %Array** %73 - store double 4.200000e-01, double* %74 - store %Array* %targets, %Array** %75 - call void @__quantum__qis__exp__ctl(%Array* %ctls, { %Array*, double, %Array* }* %72) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__inline__5, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis__inline__5, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %71, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - %paulis__inline__6 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %76 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__inline__6, i64 0) - %77 = bitcast i8* %76 to i2* - %78 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__inline__6, i64 1) - %79 = bitcast i8* %78 to i2* - %80 = load i2, i2* @PauliX - %81 = load i2, i2* @PauliY - store i2 %80, i2* %77 - store i2 %81, i2* %79 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__inline__6, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i64 1) - %82 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %83 = bitcast %Tuple* %82 to { %Array*, double, %Array* }* - %84 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %83, i64 0, i32 0 - %85 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %83, i64 0, i32 1 - %86 = getelementptr { %Array*, double, %Array* }, { %Array*, double, %Array* }* %83, i64 0, i32 2 - store %Array* %paulis__inline__6, %Array** %84 - store double 4.200000e-01, double* %85 - store %Array* %targets, %Array** %86 - call void @__quantum__qis__exp__ctladj(%Array* %ctls, { %Array*, double, %Array* }* %83) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__inline__6, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis__inline__6, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %82, i64 -1) - %87 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %88 = bitcast i8* %87 to %Qubit** - %qb__inline__7 = load %Qubit*, %Qubit** %88 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__7) - %89 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) - %90 = bitcast i8* %89 to %Qubit** - %qb__inline__8 = load %Qubit*, %Qubit** %90 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__8) - %91 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %targets, i64 0) - %92 = bitcast i8* %91 to %Qubit** - %93 = load %Qubit*, %Qubit** %92 - %94 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %93) - %95 = load %Result*, %Result** @ResultZero - %96 = call i1 @__quantum__rt__result_equal(%Result* %94, %Result* %95) - %97 = xor i1 %96, true - %98 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %targets, i64 1) - %99 = bitcast i8* %98 to %Qubit** - %100 = load %Qubit*, %Qubit** %99 - %101 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %100) - %102 = load %Result*, %Result** @ResultZero - %103 = call i1 @__quantum__rt__result_equal(%Result* %101, %Result* %102) - %104 = xor i1 %103, true - %105 = or i1 %97, %104 - br i1 %105, label %then0__9, label %continue__9 - -then0__9: ; preds = %else__1 - store i64 72, i64* %res +continue__8: ; preds = %then0__8, %continue__7 + %53 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) + %54 = bitcast i8* %53 to %Qubit** + %qubit = load %Qubit*, %Qubit** %54, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit) + %55 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) + %56 = bitcast i8* %55 to %Qubit** + %qubit__1 = load %Qubit*, %Qubit** %56, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + %paulis__2 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) + %57 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__2, i64 0) + %58 = bitcast i8* %57 to i2* + %59 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__2, i64 1) + %60 = bitcast i8* %59 to i2* + %61 = load i2, i2* @PauliX, align 1 + %62 = load i2, i2* @PauliY, align 1 + store i2 %61, i2* %58, align 1 + store i2 %62, i2* %60, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__2, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) + %63 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) + %64 = bitcast %Tuple* %63 to { %Array*, double, %Array* }* + %65 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 0 + %66 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 1 + %67 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 2 + store %Array* %paulis__2, %Array** %65, align 8 + store double 4.200000e-01, double* %66, align 8 + store %Array* %targets, %Array** %67, align 8 + call void @__quantum__qis__exp__ctl(%Array* %ctls, { %Array*, double, %Array* }* %64) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__2, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %paulis__2, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %63, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + %paulis__3 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) + %68 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__3, i64 0) + %69 = bitcast i8* %68 to i2* + %70 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__3, i64 1) + %71 = bitcast i8* %70 to i2* + %72 = load i2, i2* @PauliX, align 1 + %73 = load i2, i2* @PauliY, align 1 + store i2 %72, i2* %69, align 1 + store i2 %73, i2* %71, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__3, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) + %74 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) + %75 = bitcast %Tuple* %74 to { %Array*, double, %Array* }* + %76 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 0 + %77 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 1 + %78 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 2 + store %Array* %paulis__3, %Array** %76, align 8 + store double 4.200000e-01, double* %77, align 8 + store %Array* %targets, %Array** %78, align 8 + call void @__quantum__qis__exp__ctladj(%Array* %ctls, { %Array*, double, %Array* }* %75) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__3, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %paulis__3, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %74, i32 -1) + %79 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) + %80 = bitcast i8* %79 to %Qubit** + %qubit__2 = load %Qubit*, %Qubit** %80, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__2) + %81 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) + %82 = bitcast i8* %81 to %Qubit** + %qubit__3 = load %Qubit*, %Qubit** %82, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__3) + %83 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %targets, i64 0) + %84 = bitcast i8* %83 to %Qubit** + %85 = load %Qubit*, %Qubit** %84, align 8 + %86 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %85) + %87 = call %Result* @__quantum__rt__result_get_zero() + %88 = call i1 @__quantum__rt__result_equal(%Result* %86, %Result* %87) + %89 = xor i1 %88, true + br i1 %89, label %then0__9, label %continue__9 + +then0__9: ; preds = %continue__8 + store i64 2, i64* %res, align 4 br label %continue__9 -continue__9: ; preds = %then0__9, %else__1 - call void @__quantum__rt__result_update_reference_count(%Result* %94, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %101, i64 -1) - br label %continue__8 - -continue__8: ; preds = %continue__9, %then0__8 +continue__9: ; preds = %then0__9, %continue__8 + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %49, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %86, i32 -1) call void @__quantum__rt__qubit_release_array(%Array* %targets) call void @__quantum__rt__qubit_release_array(%Array* %ctls) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %targets, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %49, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %56, i64 -1) - %106 = load i64, i64* %res - %107 = icmp ne i64 %106, 0 - br i1 %107, label %then0__10, label %continue__10 - -then0__10: ; preds = %continue__8 - %108 = add i64 70, %106 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %0, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %3, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %7, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %11, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %15, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %19, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %30, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i64 -1) - ret i64 %108 - -continue__10: ; preds = %continue__8 + %90 = load i64, i64* %res, align 4 + %91 = icmp ne i64 %90, 0 + br i1 %91, label %then0__10, label %continue__10 + +then0__10: ; preds = %continue__9 + %92 = add i64 70, %90 + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) + ret i64 %92 + +continue__10: ; preds = %continue__9 %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 3) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 1) - %109 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %110 = bitcast i8* %109 to %Qubit** - %qb__inline__9 = load %Qubit*, %Qubit** %110 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__9) - %111 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %112 = bitcast i8* %111 to %Qubit** - %qb__inline__10 = load %Qubit*, %Qubit** %112 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__10) - %bases__inline__11 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 3) - %113 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases__inline__11, i64 0) - %114 = bitcast i8* %113 to i2* - %115 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases__inline__11, i64 1) - %116 = bitcast i8* %115 to i2* - %117 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases__inline__11, i64 2) - %118 = bitcast i8* %117 to i2* - %119 = load i2, i2* @PauliX - %120 = load i2, i2* @PauliZ - %121 = load i2, i2* @PauliX - store i2 %119, i2* %114 - store i2 %120, i2* %116 - store i2 %121, i2* %118 - call void @__quantum__rt__array_update_alias_count(%Array* %bases__inline__11, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 1) - %122 = call %Result* @__quantum__qis__measure__body(%Array* %bases__inline__11, %Array* %qs) - call void @__quantum__rt__array_update_alias_count(%Array* %bases__inline__11, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %bases__inline__11, i64 -1) - %123 = load %Result*, %Result** @ResultZero - %124 = call i1 @__quantum__rt__result_equal(%Result* %122, %Result* %123) - %125 = xor i1 %124, true - br i1 %125, label %then0__11, label %continue__11 + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) + %93 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) + %94 = bitcast i8* %93 to %Qubit** + %qubit__4 = load %Qubit*, %Qubit** %94, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__4) + %95 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) + %96 = bitcast i8* %95 to %Qubit** + %qubit__5 = load %Qubit*, %Qubit** %96, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__5) + %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 3) + %97 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) + %98 = bitcast i8* %97 to i2* + %99 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 1) + %100 = bitcast i8* %99 to i2* + %101 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 2) + %102 = bitcast i8* %101 to i2* + %103 = load i2, i2* @PauliX, align 1 + %104 = load i2, i2* @PauliZ, align 1 + %105 = load i2, i2* @PauliX, align 1 + store i2 %103, i2* %98, align 1 + store i2 %104, i2* %100, align 1 + store i2 %105, i2* %102, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) + %106 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qs) + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) + %107 = call %Result* @__quantum__rt__result_get_zero() + %108 = call i1 @__quantum__rt__result_equal(%Result* %106, %Result* %107) + %109 = xor i1 %108, true + br i1 %109, label %then0__11, label %continue__11 then0__11: ; preds = %continue__10 - store i64 80, i64* %res + store i64 80, i64* %res, align 4 br label %continue__11 continue__11: ; preds = %then0__11, %continue__10 - %126 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %127 = bitcast i8* %126 to %Qubit** - %qb__inline__12 = load %Qubit*, %Qubit** %127 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__12) - %128 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %129 = bitcast i8* %128 to %Qubit** - %qb__inline__13 = load %Qubit*, %Qubit** %129 - call void @__quantum__qis__h__body(%Qubit* %qb__inline__13) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %106, i32 -1) call void @__quantum__rt__qubit_release_array(%Array* %qs) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qs, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %122, i64 -1) - %130 = load i64, i64* %res - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %0, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %3, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %7, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %11, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %15, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %19, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %30, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i64 -1) - ret i64 %130 + %110 = load i64, i64* %res, align 4 + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) + ret i64 %110 } define void @Microsoft__Quantum__Intrinsic__X__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %2) ret void } @@ -959,8 +566,8 @@ entry: define void @Microsoft__Quantum__Intrinsic__X__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %2) ret void } @@ -968,10 +575,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__X__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %3, %Qubit* %4) ret void } @@ -979,21 +586,21 @@ entry: define void @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %3, %Qubit* %4) ret void } -declare %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]*, [2 x void (%Tuple*, i64)*]*, %Tuple*) +declare %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]*, [2 x void (%Tuple*, i32)*]*, %Tuple*) define void @Microsoft__Quantum__Intrinsic__Y__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %2) ret void } @@ -1001,8 +608,8 @@ entry: define void @Microsoft__Quantum__Intrinsic__Y__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %2) ret void } @@ -1010,10 +617,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1021,10 +628,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1032,8 +639,8 @@ entry: define void @Microsoft__Quantum__Intrinsic__Z__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %2) ret void } @@ -1041,8 +648,8 @@ entry: define void @Microsoft__Quantum__Intrinsic__Z__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %2) ret void } @@ -1050,10 +657,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1061,10 +668,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1072,8 +679,8 @@ entry: define void @Microsoft__Quantum__Intrinsic__H__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %2) ret void } @@ -1081,8 +688,8 @@ entry: define void @Microsoft__Quantum__Intrinsic__H__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %2) ret void } @@ -1090,10 +697,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__H__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1101,10 +708,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__H__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1112,8 +719,8 @@ entry: define void @Microsoft__Quantum__Intrinsic__S__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %2) ret void } @@ -1121,8 +728,8 @@ entry: define void @Microsoft__Quantum__Intrinsic__S__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %2) ret void } @@ -1130,10 +737,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__S__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1141,10 +748,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1152,8 +759,8 @@ entry: define void @Microsoft__Quantum__Intrinsic__T__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__T__body(%Qubit* %2) ret void } @@ -1161,8 +768,8 @@ entry: define void @Microsoft__Quantum__Intrinsic__T__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr { %Qubit* }, { %Qubit* }* %0, i64 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__T__adj(%Qubit* %2) ret void } @@ -1170,10 +777,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__T__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1181,10 +788,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__T__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1192,12 +799,12 @@ entry: define void @Microsoft__Quantum__Intrinsic__R__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { i2, double, %Qubit* }* - %1 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 1 - %3 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 2 - %4 = load i2, i2* %1 - %5 = load double, double* %2 - %6 = load %Qubit*, %Qubit** %3 + %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 + %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 + %4 = load i2, i2* %1, align 1 + %5 = load double, double* %2, align 8 + %6 = load %Qubit*, %Qubit** %3, align 8 call void @Microsoft__Quantum__Intrinsic__R__body(i2 %4, double %5, %Qubit* %6) ret void } @@ -1205,12 +812,12 @@ entry: define void @Microsoft__Quantum__Intrinsic__R__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { i2, double, %Qubit* }* - %1 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 1 - %3 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i64 0, i32 2 - %4 = load i2, i2* %1 - %5 = load double, double* %2 - %6 = load %Qubit*, %Qubit** %3 + %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 + %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 + %4 = load i2, i2* %1, align 1 + %5 = load double, double* %2, align 8 + %6 = load %Qubit*, %Qubit** %3, align 8 call void @Microsoft__Quantum__Intrinsic__R__adj(i2 %4, double %5, %Qubit* %6) ret void } @@ -1218,10 +825,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__R__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, { i2, double, %Qubit* }* }* - %1 = getelementptr { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load { i2, double, %Qubit* }*, { i2, double, %Qubit* }** %2 + %1 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load { i2, double, %Qubit* }*, { i2, double, %Qubit* }** %2, align 8 call void @Microsoft__Quantum__Intrinsic__R__ctl(%Array* %3, { i2, double, %Qubit* }* %4) ret void } @@ -1229,10 +836,10 @@ entry: define void @Microsoft__Quantum__Intrinsic__R__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, { i2, double, %Qubit* }* }* - %1 = getelementptr { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load { i2, double, %Qubit* }*, { i2, double, %Qubit* }** %2 + %1 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load { i2, double, %Qubit* }*, { i2, double, %Qubit* }** %2, align 8 call void @Microsoft__Quantum__Intrinsic__R__ctladj(%Array* %3, { i2, double, %Qubit* }* %4) ret void } @@ -1240,159 +847,521 @@ entry: define void @Lifted__PartialApplication__1__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i64 0, i32 1 - %2 = load i2, i2* %1 - %3 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i64 0, i32 2 - %4 = load double, double* %3 + %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 1 + %2 = load i2, i2* %1, align 1 + %3 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 2 + %4 = load double, double* %3, align 8 %5 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %6 = getelementptr { %Qubit* }, { %Qubit* }* %5, i64 0, i32 0 - %7 = load %Qubit*, %Qubit** %6 + %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 + %7 = load %Qubit*, %Qubit** %6, align 8 %8 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) %9 = bitcast %Tuple* %8 to { i2, double, %Qubit* }* - %10 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i64 0, i32 0 - %11 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i64 0, i32 1 - %12 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i64 0, i32 2 - store i2 %2, i2* %10 - store double %4, double* %11 - store %Qubit* %7, %Qubit** %12 - %13 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i64 0, i32 0 - %14 = load %Callable*, %Callable** %13 + %10 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 0 + %11 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 1 + %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 2 + store i2 %2, i2* %10, align 1 + store double %4, double* %11, align 8 + store %Qubit* %7, %Qubit** %12, align 8 + %13 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 + %14 = load %Callable*, %Callable** %13, align 8 call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) ret void } define void @Lifted__PartialApplication__1__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i64 0, i32 1 - %2 = load i2, i2* %1 - %3 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i64 0, i32 2 - %4 = load double, double* %3 + %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 1 + %2 = load i2, i2* %1, align 1 + %3 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 2 + %4 = load double, double* %3, align 8 %5 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %6 = getelementptr { %Qubit* }, { %Qubit* }* %5, i64 0, i32 0 - %7 = load %Qubit*, %Qubit** %6 + %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 + %7 = load %Qubit*, %Qubit** %6, align 8 %8 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) %9 = bitcast %Tuple* %8 to { i2, double, %Qubit* }* - %10 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i64 0, i32 0 - %11 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i64 0, i32 1 - %12 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i64 0, i32 2 - store i2 %2, i2* %10 - store double %4, double* %11 - store %Qubit* %7, %Qubit** %12 - %13 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i64 0, i32 0 - %14 = load %Callable*, %Callable** %13 + %10 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 0 + %11 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 1 + %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 2 + store i2 %2, i2* %10, align 1 + store double %4, double* %11, align 8 + store %Qubit* %7, %Qubit** %12, align 8 + %13 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 + %14 = load %Callable*, %Callable** %13, align 8 %15 = call %Callable* @__quantum__rt__callable_copy(%Callable* %14, i1 false) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %15, i64 1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 1) call void @__quantum__rt__callable_make_adjoint(%Callable* %15) call void @__quantum__rt__callable_invoke(%Callable* %15, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %15, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) ret void } define void @Lifted__PartialApplication__1__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 %5 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %6 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i64 0, i32 1 - %7 = load i2, i2* %6 - %8 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i64 0, i32 2 - %9 = load double, double* %8 + %6 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 1 + %7 = load i2, i2* %6, align 1 + %8 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 2 + %9 = load double, double* %8, align 8 %10 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) %11 = bitcast %Tuple* %10 to { i2, double, %Qubit* }* - %12 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i64 0, i32 0 - %13 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i64 0, i32 1 - %14 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i64 0, i32 2 - store i2 %7, i2* %12 - store double %9, double* %13 - store %Qubit* %4, %Qubit** %14 + %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 0 + %13 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 1 + %14 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 2 + store i2 %7, i2* %12, align 1 + store double %9, double* %13, align 8 + store %Qubit* %4, %Qubit** %14, align 8 %15 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) %16 = bitcast %Tuple* %15 to { %Array*, { i2, double, %Qubit* }* }* - %17 = getelementptr { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i64 0, i32 0 - %18 = getelementptr { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i64 0, i32 1 - store %Array* %3, %Array** %17 - store { i2, double, %Qubit* }* %11, { i2, double, %Qubit* }** %18 - %19 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i64 0, i32 0 - %20 = load %Callable*, %Callable** %19 + %17 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 0 + %18 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 1 + store %Array* %3, %Array** %17, align 8 + store { i2, double, %Qubit* }* %11, { i2, double, %Qubit* }** %18, align 8 + %19 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 0 + %20 = load %Callable*, %Callable** %19, align 8 %21 = call %Callable* @__quantum__rt__callable_copy(%Callable* %20, i1 false) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %21, i64 1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 1) call void @__quantum__rt__callable_make_controlled(%Callable* %21) call void @__quantum__rt__callable_invoke(%Callable* %21, %Tuple* %15, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %10, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %15, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %21, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %21, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %10, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %21, i32 -1) ret void } define void @Lifted__PartialApplication__1__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 0 - %2 = getelementptr { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i64 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 %5 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %6 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i64 0, i32 1 - %7 = load i2, i2* %6 - %8 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i64 0, i32 2 - %9 = load double, double* %8 + %6 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 1 + %7 = load i2, i2* %6, align 1 + %8 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 2 + %9 = load double, double* %8, align 8 %10 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) %11 = bitcast %Tuple* %10 to { i2, double, %Qubit* }* - %12 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i64 0, i32 0 - %13 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i64 0, i32 1 - %14 = getelementptr { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i64 0, i32 2 - store i2 %7, i2* %12 - store double %9, double* %13 - store %Qubit* %4, %Qubit** %14 + %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 0 + %13 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 1 + %14 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 2 + store i2 %7, i2* %12, align 1 + store double %9, double* %13, align 8 + store %Qubit* %4, %Qubit** %14, align 8 %15 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) %16 = bitcast %Tuple* %15 to { %Array*, { i2, double, %Qubit* }* }* - %17 = getelementptr { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i64 0, i32 0 - %18 = getelementptr { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i64 0, i32 1 - store %Array* %3, %Array** %17 - store { i2, double, %Qubit* }* %11, { i2, double, %Qubit* }** %18 - %19 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i64 0, i32 0 - %20 = load %Callable*, %Callable** %19 + %17 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 0 + %18 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 1 + store %Array* %3, %Array** %17, align 8 + store { i2, double, %Qubit* }* %11, { i2, double, %Qubit* }** %18, align 8 + %19 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 0 + %20 = load %Callable*, %Callable** %19, align 8 %21 = call %Callable* @__quantum__rt__callable_copy(%Callable* %20, i1 false) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %21, i64 1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 1) call void @__quantum__rt__callable_make_adjoint(%Callable* %21) call void @__quantum__rt__callable_make_controlled(%Callable* %21) call void @__quantum__rt__callable_invoke(%Callable* %21, %Tuple* %15, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %10, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %15, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %21, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %21, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %10, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %21, i32 -1) ret void } -define void @MemoryManagement__1__RefCount(%Tuple* %capture-tuple, i64 %count-change) { +define void @MemoryManagement__1__RefCount(%Tuple* %capture-tuple, i32 %count-change) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i64 0, i32 0 - %2 = load %Callable*, %Callable** %1 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %2, i64 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i64 %count-change) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i64 %count-change) + %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) ret void } -define void @MemoryManagement__1__AliasCount(%Tuple* %capture-tuple, i64 %count-change) { +define void @MemoryManagement__1__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i64 0, i32 0 - %2 = load %Callable*, %Callable** %1 - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %2, i64 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i64 %count-change) - call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i64 %count-change) + %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) + ret void +} + +declare %Array* @__quantum__rt__array_create_1d(i32, i64) + +declare void @__quantum__qis__exp__body(%Array*, double, %Array*) + +declare void @__quantum__rt__array_update_reference_count(%Array*, i32) + +declare void @__quantum__qis__exp__adj(%Array*, double, %Array*) + +declare void @__quantum__qis__exp__ctl(%Array*, { %Array*, double, %Array* }*) + +declare void @__quantum__qis__exp__ctladj(%Array*, { %Array*, double, %Array* }*) + +declare %Result* @__quantum__qis__measure__body(%Array*, %Array*) + +define void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__s__body(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__s__body(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__s__adj(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__s__adj(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__s__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__s__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__s__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__s__ctladj(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__Exp__body(%Array* %paulis, double %theta, %Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + call void @__quantum__qis__exp__body(%Array* %paulis, double %theta, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Exp__adj(%Array* %paulis, double %theta, %Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + call void @__quantum__qis__exp__adj(%Array* %paulis, double %theta, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Exp__ctl(%Array* %__controlQubits__, { %Array*, double, %Array* }* %0) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + %1 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 0 + %paulis = load %Array*, %Array** %1, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + %2 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 1 + %theta = load double, double* %2, align 8 + %3 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 2 + %qubits = load %Array*, %Array** %3, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) + %5 = bitcast %Tuple* %4 to { %Array*, double, %Array* }* + %6 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 0 + %7 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 1 + %8 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 2 + store %Array* %paulis, %Array** %6, align 8 + store double %theta, double* %7, align 8 + store %Array* %qubits, %Array** %8, align 8 + call void @__quantum__qis__exp__ctl(%Array* %__controlQubits__, { %Array*, double, %Array* }* %5) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Exp__ctladj(%Array* %__controlQubits__, { %Array*, double, %Array* }* %0) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + %1 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 0 + %paulis = load %Array*, %Array** %1, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + %2 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 1 + %theta = load double, double* %2, align 8 + %3 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 2 + %qubits = load %Array*, %Array** %3, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) + %5 = bitcast %Tuple* %4 to { %Array*, double, %Array* }* + %6 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 0 + %7 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 1 + %8 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 2 + store %Array* %paulis, %Array** %6, align 8 + store double %theta, double* %7, align 8 + store %Array* %qubits, %Array** %8, align 8 + call void @__quantum__qis__exp__ctladj(%Array* %__controlQubits__, { %Array*, double, %Array* }* %5) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__T__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__t__body(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__t__body(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__T__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__t__adj(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__t__adj(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__t__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__t__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__t__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__t__ctladj(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__h__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__h__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__h__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__x__body(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__x__body(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__x__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__x__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__x__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__x__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__R__body(i2 %pauli, double %theta, %Qubit* %qubit) { +entry: + call void @__quantum__qis__r__body(i2 %pauli, double %theta, %Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__r__body(i2, double, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__R__adj(i2 %pauli, double %theta, %Qubit* %qubit) { +entry: + call void @__quantum__qis__r__adj(i2 %pauli, double %theta, %Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__r__adj(i2, double, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__R__ctl(%Array* %__controlQubits__, { i2, double, %Qubit* }* %0) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 + %pauli = load i2, i2* %1, align 1 + %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 + %theta = load double, double* %2, align 8 + %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 + %qubit = load %Qubit*, %Qubit** %3, align 8 + %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) + %5 = bitcast %Tuple* %4 to { i2, double, %Qubit* }* + %6 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 0 + %7 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 1 + %8 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 2 + store i2 %pauli, i2* %6, align 1 + store double %theta, double* %7, align 8 + store %Qubit* %qubit, %Qubit** %8, align 8 + call void @__quantum__qis__r__ctl(%Array* %__controlQubits__, { i2, double, %Qubit* }* %5) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) + ret void +} + +declare void @__quantum__qis__r__ctl(%Array*, { i2, double, %Qubit* }*) + +define void @Microsoft__Quantum__Intrinsic__R__ctladj(%Array* %__controlQubits__, { i2, double, %Qubit* }* %0) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 + %pauli = load i2, i2* %1, align 1 + %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 + %theta = load double, double* %2, align 8 + %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 + %qubit = load %Qubit*, %Qubit** %3, align 8 + %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) + %5 = bitcast %Tuple* %4 to { i2, double, %Qubit* }* + %6 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 0 + %7 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 1 + %8 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 2 + store i2 %pauli, i2* %6, align 1 + store double %theta, double* %7, align 8 + store %Qubit* %qubit, %Qubit** %8, align 8 + call void @__quantum__qis__r__ctladj(%Array* %__controlQubits__, { i2, double, %Qubit* }* %5) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) + ret void +} + +declare void @__quantum__qis__r__ctladj(%Array*, { i2, double, %Qubit* }*) + +define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %bases, %Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +define void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__z__body(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__z__body(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__z__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__z__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__y__body(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__y__body(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__y__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__y__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) ret void } -declare void @__quantum__rt__tuple_update_alias_count(%Tuple*, i64) +declare void @__quantum__rt__tuple_update_alias_count(%Tuple*, i32) attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/test/FullstateSimulator/qsharp/qir-test-simulator.csproj b/src/QirRuntime/test/FullstateSimulator/qsharp/qir-test-simulator.csproj new file mode 100644 index 00000000000..5166db5e375 --- /dev/null +++ b/src/QirRuntime/test/FullstateSimulator/qsharp/qir-test-simulator.csproj @@ -0,0 +1,14 @@ + + + + Exe + netcoreapp3.1 + True + false + + + + + + + diff --git a/src/QirRuntime/test/FullstateSimulator/qir-test-simulator.qs b/src/QirRuntime/test/FullstateSimulator/qsharp/qir-test-simulator.qs similarity index 70% rename from src/QirRuntime/test/FullstateSimulator/qir-test-simulator.qs rename to src/QirRuntime/test/FullstateSimulator/qsharp/qir-test-simulator.qs index b32c6bed364..3b6d3eee483 100644 --- a/src/QirRuntime/test/FullstateSimulator/qir-test-simulator.qs +++ b/src/QirRuntime/test/FullstateSimulator/qsharp/qir-test-simulator.qs @@ -10,18 +10,18 @@ namespace Microsoft.Quantum.Testing.QIR operation InvokeAllVariants(op : (Qubit => Unit is Adj + Ctl)) : Int { mutable res = 0; - using((target, ctls) = (Qubit(), Qubit[2])) + use (target, ctls) = (Qubit(), Qubit[2]) { op(target); Adjoint op(target); - if (M(target) != Zero) { let res = 1; } + if (M(target) != Zero) { set res = 1; } else { H(ctls[0]); H(ctls[1]); Controlled op(ctls, target); Adjoint Controlled op(ctls, target); - if (M(target) != Zero) { return 2; } + if (M(target) != Zero) { set res = 2; } H(ctls[0]); H(ctls[1]); } @@ -33,33 +33,33 @@ namespace Microsoft.Quantum.Testing.QIR operation Test_Simulator_QIS() : Int { mutable res = 0; - let res = InvokeAllVariants(X); + set res = InvokeAllVariants(X); if (res != 0) { return res; } - let res = InvokeAllVariants(Y); + set res = InvokeAllVariants(Y); if (res != 0) { return 10 + res; } - let res = InvokeAllVariants(Z); + set res = InvokeAllVariants(Z); if (res != 0) { return 20 + res; } - let res = InvokeAllVariants(H); + set res = InvokeAllVariants(H); if (res != 0) { return 30 + res; } - let res = InvokeAllVariants(S); + set res = InvokeAllVariants(S); if (res != 0) { return 40 + res; } - let res = InvokeAllVariants(T); + set res = InvokeAllVariants(T); if (res != 0) { return 50 + res; } - let res = InvokeAllVariants(R(PauliX, 0.42, _)); + set res = InvokeAllVariants(R(PauliX, 0.42, _)); if (res != 0) { return 60 + res; } - using((targets, ctls) = (Qubit[2], Qubit[2])) + use (targets, ctls) = (Qubit[2], Qubit[2]) { let theta = 0.42; Exp([PauliX, PauliY], theta, targets); Adjoint Exp([PauliX, PauliY], theta, targets); - if (M(target) != Zero) { let res = 1; } + if (M(targets[0]) != Zero) { set res = 1; } H(ctls[0]); H(ctls[1]); @@ -67,15 +67,15 @@ namespace Microsoft.Quantum.Testing.QIR Adjoint Controlled Exp(ctls, ([PauliX, PauliY], theta, targets)); H(ctls[0]); H(ctls[1]); - if (M(target) != Zero) { let res = 70 + 2; } + if (M(targets[0]) != Zero) { set res = 2; } } if (res != 0) { return 70 + res; } - using (qs = Qubit[3]) + use qs = Qubit[3] { H(qs[0]); H(qs[2]); - if (Measure([PauliX, PauliZ, PauliX], qs) != zero) { let res = 80; } + if (Measure([PauliX, PauliZ, PauliX], qs) != Zero) { set res = 80; } } return res; } diff --git a/src/QirRuntime/test/FullstateSimulator/qsharp/qir/qir-test-simulator.ll b/src/QirRuntime/test/FullstateSimulator/qsharp/qir/qir-test-simulator.ll new file mode 100644 index 00000000000..4b4b24c51a8 --- /dev/null +++ b/src/QirRuntime/test/FullstateSimulator/qsharp/qir/qir-test-simulator.ll @@ -0,0 +1,1367 @@ + +%Range = type { i64, i64, i64 } +%Tuple = type opaque +%Callable = type opaque +%Qubit = type opaque +%Array = type opaque +%Result = type opaque + +@PauliI = constant i2 0 +@PauliX = constant i2 1 +@PauliY = constant i2 -1 +@PauliZ = constant i2 -2 +@EmptyRange = internal constant %Range { i64 0, i64 1, i64 -1 } +@Microsoft__Quantum__Intrinsic__X = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper] +@Microsoft__Quantum__Intrinsic__Y = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper] +@Microsoft__Quantum__Intrinsic__Z = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper] +@Microsoft__Quantum__Intrinsic__H = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__ctladj__wrapper] +@Microsoft__Quantum__Intrinsic__S = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper] +@Microsoft__Quantum__Intrinsic__T = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__ctladj__wrapper] +@Microsoft__Quantum__Intrinsic__R = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__ctladj__wrapper] +@PartialApplication__1 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__ctladj__wrapper] +@MemoryManagement__1 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__1__RefCount, void (%Tuple*, i32)* @MemoryManagement__1__AliasCount] + +@Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS = alias i64 (), i64 ()* @Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS__body + +define i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %op) { +entry: + call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 1) + %res = alloca i64, align 8 + store i64 0, i64* %res, align 4 + %target = call %Qubit* @__quantum__rt__qubit_allocate() + %ctls = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) + %1 = bitcast %Tuple* %0 to { %Qubit* }* + %2 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %1, i32 0, i32 0 + store %Qubit* %target, %Qubit** %2, align 8 + call void @__quantum__rt__callable_invoke(%Callable* %op, %Tuple* %0, %Tuple* null) + %3 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 1) + call void @__quantum__rt__callable_make_adjoint(%Callable* %3) + %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) + %5 = bitcast %Tuple* %4 to { %Qubit* }* + %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 + store %Qubit* %target, %Qubit** %6, align 8 + call void @__quantum__rt__callable_invoke(%Callable* %3, %Tuple* %4, %Tuple* null) + %7 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %target) + %8 = call %Result* @__quantum__rt__result_get_zero() + %9 = call i1 @__quantum__rt__result_equal(%Result* %7, %Result* %8) + %10 = xor i1 %9, true + br i1 %10, label %then0__1, label %else__1 + +then0__1: ; preds = %entry + store i64 1, i64* %res, align 4 + br label %continue__1 + +else__1: ; preds = %entry + %11 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) + %12 = bitcast i8* %11 to %Qubit** + %qubit = load %Qubit*, %Qubit** %12, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit) + %13 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) + %14 = bitcast i8* %13 to %Qubit** + %qubit__1 = load %Qubit*, %Qubit** %14, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__1) + %15 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 1) + call void @__quantum__rt__callable_make_controlled(%Callable* %15) + %16 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) + %17 = bitcast %Tuple* %16 to { %Array*, %Qubit* }* + %18 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %17, i32 0, i32 0 + %19 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %17, i32 0, i32 1 + store %Array* %ctls, %Array** %18, align 8 + store %Qubit* %target, %Qubit** %19, align 8 + call void @__quantum__rt__callable_invoke(%Callable* %15, %Tuple* %16, %Tuple* null) + %20 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) + call void @__quantum__rt__capture_update_reference_count(%Callable* %20, i32 1) + call void @__quantum__rt__callable_make_controlled(%Callable* %20) + call void @__quantum__rt__callable_make_adjoint(%Callable* %20) + %21 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) + %22 = bitcast %Tuple* %21 to { %Array*, %Qubit* }* + %23 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %22, i32 0, i32 0 + %24 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %22, i32 0, i32 1 + store %Array* %ctls, %Array** %23, align 8 + store %Qubit* %target, %Qubit** %24, align 8 + call void @__quantum__rt__callable_invoke(%Callable* %20, %Tuple* %21, %Tuple* null) + %25 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %target) + %26 = call %Result* @__quantum__rt__result_get_zero() + %27 = call i1 @__quantum__rt__result_equal(%Result* %25, %Result* %26) + %28 = xor i1 %27, true + br i1 %28, label %then0__2, label %continue__2 + +then0__2: ; preds = %else__1 + store i64 2, i64* %res, align 4 + br label %continue__2 + +continue__2: ; preds = %then0__2, %else__1 + %29 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) + %30 = bitcast i8* %29 to %Qubit** + %qubit__2 = load %Qubit*, %Qubit** %30, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__2) + %31 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) + %32 = bitcast i8* %31 to %Qubit** + %qubit__3 = load %Qubit*, %Qubit** %32, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__3) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %16, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %20, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %20, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %21, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %25, i32 -1) + br label %continue__1 + +continue__1: ; preds = %continue__2, %then0__1 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %7, i32 -1) + call void @__quantum__rt__qubit_release(%Qubit* %target) + call void @__quantum__rt__qubit_release_array(%Array* %ctls) + %33 = load i64, i64* %res, align 4 + call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 -1) + ret i64 %33 +} + +declare void @__quantum__rt__capture_update_alias_count(%Callable*, i32) + +declare void @__quantum__rt__callable_update_alias_count(%Callable*, i32) + +declare %Qubit* @__quantum__rt__qubit_allocate() + +declare %Array* @__quantum__rt__qubit_allocate_array(i64) + +declare void @__quantum__rt__array_update_alias_count(%Array*, i32) + +declare void @__quantum__rt__callable_invoke(%Callable*, %Tuple*, %Tuple*) + +declare %Tuple* @__quantum__rt__tuple_create(i64) + +declare %Callable* @__quantum__rt__callable_copy(%Callable*, i1) + +declare void @__quantum__rt__capture_update_reference_count(%Callable*, i32) + +declare void @__quantum__rt__callable_make_adjoint(%Callable*) + +define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qubit) { +entry: + %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 1) + %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) + %1 = bitcast i8* %0 to i2* + %2 = load i2, i2* @PauliZ, align 1 + store i2 %2, i2* %1, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) + %qubits = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) + %3 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) + %4 = bitcast i8* %3 to %Qubit** + store %Qubit* %qubit, %Qubit** %4, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %5 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %qubits, i32 -1) + ret %Result* %5 +} + +declare %Result* @__quantum__rt__result_get_zero() + +declare i1 @__quantum__rt__result_equal(%Result*, %Result*) + +declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) + +declare void @__quantum__qis__h__body(%Qubit*) + +declare void @__quantum__rt__callable_make_controlled(%Callable*) + +declare void @__quantum__rt__callable_update_reference_count(%Callable*, i32) + +declare void @__quantum__rt__tuple_update_reference_count(%Tuple*, i32) + +declare void @__quantum__rt__result_update_reference_count(%Result*, i32) + +declare void @__quantum__rt__qubit_release(%Qubit*) + +declare void @__quantum__rt__qubit_release_array(%Array*) + +define i64 @Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS__body() #0 { +entry: + %res = alloca i64, align 8 + store i64 0, i64* %res, align 4 + %0 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__X, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %1 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %0) + store i64 %1, i64* %res, align 4 + %2 = icmp ne i64 %1, 0 + br i1 %2, label %then0__1, label %continue__1 + +then0__1: ; preds = %entry + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + ret i64 %1 + +continue__1: ; preds = %entry + %3 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Y, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %4 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %3) + store i64 %4, i64* %res, align 4 + %5 = icmp ne i64 %4, 0 + br i1 %5, label %then0__2, label %continue__2 + +then0__2: ; preds = %continue__1 + %6 = add i64 10, %4 + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + ret i64 %6 + +continue__2: ; preds = %continue__1 + %7 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Z, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %8 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %7) + store i64 %8, i64* %res, align 4 + %9 = icmp ne i64 %8, 0 + br i1 %9, label %then0__3, label %continue__3 + +then0__3: ; preds = %continue__2 + %10 = add i64 20, %8 + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + ret i64 %10 + +continue__3: ; preds = %continue__2 + %11 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__H, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %12 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %11) + store i64 %12, i64* %res, align 4 + %13 = icmp ne i64 %12, 0 + br i1 %13, label %then0__4, label %continue__4 + +then0__4: ; preds = %continue__3 + %14 = add i64 30, %12 + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) + ret i64 %14 + +continue__4: ; preds = %continue__3 + %15 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__S, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %16 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %15) + store i64 %16, i64* %res, align 4 + %17 = icmp ne i64 %16, 0 + br i1 %17, label %then0__5, label %continue__5 + +then0__5: ; preds = %continue__4 + %18 = add i64 40, %16 + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + ret i64 %18 + +continue__5: ; preds = %continue__4 + %19 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__T, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %20 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %19) + store i64 %20, i64* %res, align 4 + %21 = icmp ne i64 %20, 0 + br i1 %21, label %then0__6, label %continue__6 + +then0__6: ; preds = %continue__5 + %22 = add i64 50, %20 + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) + ret i64 %22 + +continue__6: ; preds = %continue__5 + %23 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Callable*, i2, double }* getelementptr ({ %Callable*, i2, double }, { %Callable*, i2, double }* null, i32 1) to i64)) + %24 = bitcast %Tuple* %23 to { %Callable*, i2, double }* + %25 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 0 + %26 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 1 + %27 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 2 + %28 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__R, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %29 = load i2, i2* @PauliX, align 1 + store %Callable* %28, %Callable** %25, align 8 + store i2 %29, i2* %26, align 1 + store double 4.200000e-01, double* %27, align 8 + %30 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__1, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %23) + %31 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %30) + store i64 %31, i64* %res, align 4 + %32 = icmp ne i64 %31, 0 + br i1 %32, label %then0__7, label %continue__7 + +then0__7: ; preds = %continue__6 + %33 = add i64 60, %31 + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) + ret i64 %33 + +continue__7: ; preds = %continue__6 + %targets = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) + %ctls = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + %paulis = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) + %34 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) + %35 = bitcast i8* %34 to i2* + %36 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) + %37 = bitcast i8* %36 to i2* + %38 = load i2, i2* @PauliX, align 1 + %39 = load i2, i2* @PauliY, align 1 + store i2 %38, i2* %35, align 1 + store i2 %39, i2* %37, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) + call void @__quantum__qis__exp__body(%Array* %paulis, double 4.200000e-01, %Array* %targets) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %paulis, i32 -1) + %paulis__1 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) + %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__1, i64 0) + %41 = bitcast i8* %40 to i2* + %42 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__1, i64 1) + %43 = bitcast i8* %42 to i2* + %44 = load i2, i2* @PauliX, align 1 + %45 = load i2, i2* @PauliY, align 1 + store i2 %44, i2* %41, align 1 + store i2 %45, i2* %43, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__1, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) + call void @__quantum__qis__exp__adj(%Array* %paulis__1, double 4.200000e-01, %Array* %targets) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__1, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %paulis__1, i32 -1) + %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %targets, i64 0) + %47 = bitcast i8* %46 to %Qubit** + %48 = load %Qubit*, %Qubit** %47, align 8 + %49 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %48) + %50 = call %Result* @__quantum__rt__result_get_zero() + %51 = call i1 @__quantum__rt__result_equal(%Result* %49, %Result* %50) + %52 = xor i1 %51, true + br i1 %52, label %then0__8, label %continue__8 + +then0__8: ; preds = %continue__7 + store i64 1, i64* %res, align 4 + br label %continue__8 + +continue__8: ; preds = %then0__8, %continue__7 + %53 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) + %54 = bitcast i8* %53 to %Qubit** + %qubit = load %Qubit*, %Qubit** %54, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit) + %55 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) + %56 = bitcast i8* %55 to %Qubit** + %qubit__1 = load %Qubit*, %Qubit** %56, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + %paulis__2 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) + %57 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__2, i64 0) + %58 = bitcast i8* %57 to i2* + %59 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__2, i64 1) + %60 = bitcast i8* %59 to i2* + %61 = load i2, i2* @PauliX, align 1 + %62 = load i2, i2* @PauliY, align 1 + store i2 %61, i2* %58, align 1 + store i2 %62, i2* %60, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__2, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) + %63 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) + %64 = bitcast %Tuple* %63 to { %Array*, double, %Array* }* + %65 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 0 + %66 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 1 + %67 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 2 + store %Array* %paulis__2, %Array** %65, align 8 + store double 4.200000e-01, double* %66, align 8 + store %Array* %targets, %Array** %67, align 8 + call void @__quantum__qis__exp__ctl(%Array* %ctls, { %Array*, double, %Array* }* %64) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__2, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %paulis__2, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %63, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + %paulis__3 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) + %68 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__3, i64 0) + %69 = bitcast i8* %68 to i2* + %70 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__3, i64 1) + %71 = bitcast i8* %70 to i2* + %72 = load i2, i2* @PauliX, align 1 + %73 = load i2, i2* @PauliY, align 1 + store i2 %72, i2* %69, align 1 + store i2 %73, i2* %71, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__3, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) + %74 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) + %75 = bitcast %Tuple* %74 to { %Array*, double, %Array* }* + %76 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 0 + %77 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 1 + %78 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 2 + store %Array* %paulis__3, %Array** %76, align 8 + store double 4.200000e-01, double* %77, align 8 + store %Array* %targets, %Array** %78, align 8 + call void @__quantum__qis__exp__ctladj(%Array* %ctls, { %Array*, double, %Array* }* %75) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis__3, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %paulis__3, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %74, i32 -1) + %79 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) + %80 = bitcast i8* %79 to %Qubit** + %qubit__2 = load %Qubit*, %Qubit** %80, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__2) + %81 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) + %82 = bitcast i8* %81 to %Qubit** + %qubit__3 = load %Qubit*, %Qubit** %82, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__3) + %83 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %targets, i64 0) + %84 = bitcast i8* %83 to %Qubit** + %85 = load %Qubit*, %Qubit** %84, align 8 + %86 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %85) + %87 = call %Result* @__quantum__rt__result_get_zero() + %88 = call i1 @__quantum__rt__result_equal(%Result* %86, %Result* %87) + %89 = xor i1 %88, true + br i1 %89, label %then0__9, label %continue__9 + +then0__9: ; preds = %continue__8 + store i64 2, i64* %res, align 4 + br label %continue__9 + +continue__9: ; preds = %then0__9, %continue__8 + call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %49, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %86, i32 -1) + call void @__quantum__rt__qubit_release_array(%Array* %targets) + call void @__quantum__rt__qubit_release_array(%Array* %ctls) + %90 = load i64, i64* %res, align 4 + %91 = icmp ne i64 %90, 0 + br i1 %91, label %then0__10, label %continue__10 + +then0__10: ; preds = %continue__9 + %92 = add i64 70, %90 + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) + ret i64 %92 + +continue__10: ; preds = %continue__9 + %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 3) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) + %93 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) + %94 = bitcast i8* %93 to %Qubit** + %qubit__4 = load %Qubit*, %Qubit** %94, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__4) + %95 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) + %96 = bitcast i8* %95 to %Qubit** + %qubit__5 = load %Qubit*, %Qubit** %96, align 8 + call void @__quantum__qis__h__body(%Qubit* %qubit__5) + %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 3) + %97 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) + %98 = bitcast i8* %97 to i2* + %99 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 1) + %100 = bitcast i8* %99 to i2* + %101 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 2) + %102 = bitcast i8* %101 to i2* + %103 = load i2, i2* @PauliX, align 1 + %104 = load i2, i2* @PauliZ, align 1 + %105 = load i2, i2* @PauliX, align 1 + store i2 %103, i2* %98, align 1 + store i2 %104, i2* %100, align 1 + store i2 %105, i2* %102, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) + %106 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qs) + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) + %107 = call %Result* @__quantum__rt__result_get_zero() + %108 = call i1 @__quantum__rt__result_equal(%Result* %106, %Result* %107) + %109 = xor i1 %108, true + br i1 %109, label %then0__11, label %continue__11 + +then0__11: ; preds = %continue__10 + store i64 80, i64* %res, align 4 + br label %continue__11 + +continue__11: ; preds = %then0__11, %continue__10 + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %106, i32 -1) + call void @__quantum__rt__qubit_release_array(%Array* %qs) + %110 = load i64, i64* %res, align 4 + call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) + ret i64 %110 +} + +define void @Microsoft__Quantum__Intrinsic__X__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__X__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__X__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %3, %Qubit* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %3, %Qubit* %4) + ret void +} + +declare %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]*, [2 x void (%Tuple*, i32)*]*, %Tuple*) + +define void @Microsoft__Quantum__Intrinsic__Y__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Y__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %3, %Qubit* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %3, %Qubit* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Z__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Z__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %3, %Qubit* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %3, %Qubit* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %3, %Qubit* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %3, %Qubit* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__S__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__S__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__S__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %3, %Qubit* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %3, %Qubit* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__T__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__T__body(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__T__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 + %2 = load %Qubit*, %Qubit** %1, align 8 + call void @Microsoft__Quantum__Intrinsic__T__adj(%Qubit* %2) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__T__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %3, %Qubit* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__T__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %3, %Qubit* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__R__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { i2, double, %Qubit* }* + %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 + %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 + %4 = load i2, i2* %1, align 1 + %5 = load double, double* %2, align 8 + %6 = load %Qubit*, %Qubit** %3, align 8 + call void @Microsoft__Quantum__Intrinsic__R__body(i2 %4, double %5, %Qubit* %6) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__R__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { i2, double, %Qubit* }* + %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 + %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 + %4 = load i2, i2* %1, align 1 + %5 = load double, double* %2, align 8 + %6 = load %Qubit*, %Qubit** %3, align 8 + call void @Microsoft__Quantum__Intrinsic__R__adj(i2 %4, double %5, %Qubit* %6) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__R__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, { i2, double, %Qubit* }* }* + %1 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load { i2, double, %Qubit* }*, { i2, double, %Qubit* }** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__R__ctl(%Array* %3, { i2, double, %Qubit* }* %4) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__R__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, { i2, double, %Qubit* }* }* + %1 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load { i2, double, %Qubit* }*, { i2, double, %Qubit* }** %2, align 8 + call void @Microsoft__Quantum__Intrinsic__R__ctladj(%Array* %3, { i2, double, %Qubit* }* %4) + ret void +} + +define void @Lifted__PartialApplication__1__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* + %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 1 + %2 = load i2, i2* %1, align 1 + %3 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 2 + %4 = load double, double* %3, align 8 + %5 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 + %7 = load %Qubit*, %Qubit** %6, align 8 + %8 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) + %9 = bitcast %Tuple* %8 to { i2, double, %Qubit* }* + %10 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 0 + %11 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 1 + %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 2 + store i2 %2, i2* %10, align 1 + store double %4, double* %11, align 8 + store %Qubit* %7, %Qubit** %12, align 8 + %13 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 + %14 = load %Callable*, %Callable** %13, align 8 + call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) + ret void +} + +define void @Lifted__PartialApplication__1__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* + %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 1 + %2 = load i2, i2* %1, align 1 + %3 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 2 + %4 = load double, double* %3, align 8 + %5 = bitcast %Tuple* %arg-tuple to { %Qubit* }* + %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 + %7 = load %Qubit*, %Qubit** %6, align 8 + %8 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) + %9 = bitcast %Tuple* %8 to { i2, double, %Qubit* }* + %10 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 0 + %11 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 1 + %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 2 + store i2 %2, i2* %10, align 1 + store double %4, double* %11, align 8 + store %Qubit* %7, %Qubit** %12, align 8 + %13 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 + %14 = load %Callable*, %Callable** %13, align 8 + %15 = call %Callable* @__quantum__rt__callable_copy(%Callable* %14, i1 false) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 1) + call void @__quantum__rt__callable_make_adjoint(%Callable* %15) + call void @__quantum__rt__callable_invoke(%Callable* %15, %Tuple* %8, %Tuple* %result-tuple) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) + ret void +} + +define void @Lifted__PartialApplication__1__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + %5 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* + %6 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 1 + %7 = load i2, i2* %6, align 1 + %8 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 2 + %9 = load double, double* %8, align 8 + %10 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) + %11 = bitcast %Tuple* %10 to { i2, double, %Qubit* }* + %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 0 + %13 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 1 + %14 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 2 + store i2 %7, i2* %12, align 1 + store double %9, double* %13, align 8 + store %Qubit* %4, %Qubit** %14, align 8 + %15 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) + %16 = bitcast %Tuple* %15 to { %Array*, { i2, double, %Qubit* }* }* + %17 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 0 + %18 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 1 + store %Array* %3, %Array** %17, align 8 + store { i2, double, %Qubit* }* %11, { i2, double, %Qubit* }** %18, align 8 + %19 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 0 + %20 = load %Callable*, %Callable** %19, align 8 + %21 = call %Callable* @__quantum__rt__callable_copy(%Callable* %20, i1 false) + call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 1) + call void @__quantum__rt__callable_make_controlled(%Callable* %21) + call void @__quantum__rt__callable_invoke(%Callable* %21, %Tuple* %15, %Tuple* %result-tuple) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %10, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %21, i32 -1) + ret void +} + +define void @Lifted__PartialApplication__1__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { +entry: + %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* + %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 + %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 + %5 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* + %6 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 1 + %7 = load i2, i2* %6, align 1 + %8 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 2 + %9 = load double, double* %8, align 8 + %10 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) + %11 = bitcast %Tuple* %10 to { i2, double, %Qubit* }* + %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 0 + %13 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 1 + %14 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 2 + store i2 %7, i2* %12, align 1 + store double %9, double* %13, align 8 + store %Qubit* %4, %Qubit** %14, align 8 + %15 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) + %16 = bitcast %Tuple* %15 to { %Array*, { i2, double, %Qubit* }* }* + %17 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 0 + %18 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 1 + store %Array* %3, %Array** %17, align 8 + store { i2, double, %Qubit* }* %11, { i2, double, %Qubit* }** %18, align 8 + %19 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 0 + %20 = load %Callable*, %Callable** %19, align 8 + %21 = call %Callable* @__quantum__rt__callable_copy(%Callable* %20, i1 false) + call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 1) + call void @__quantum__rt__callable_make_adjoint(%Callable* %21) + call void @__quantum__rt__callable_make_controlled(%Callable* %21) + call void @__quantum__rt__callable_invoke(%Callable* %21, %Tuple* %15, %Tuple* %result-tuple) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %10, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %15, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %21, i32 -1) + ret void +} + +define void @MemoryManagement__1__RefCount(%Tuple* %capture-tuple, i32 %count-change) { +entry: + %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* + %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) + ret void +} + +define void @MemoryManagement__1__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { +entry: + %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* + %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) + ret void +} + +declare %Array* @__quantum__rt__array_create_1d(i32, i64) + +declare void @__quantum__qis__exp__body(%Array*, double, %Array*) + +declare void @__quantum__rt__array_update_reference_count(%Array*, i32) + +declare void @__quantum__qis__exp__adj(%Array*, double, %Array*) + +declare void @__quantum__qis__exp__ctl(%Array*, { %Array*, double, %Array* }*) + +declare void @__quantum__qis__exp__ctladj(%Array*, { %Array*, double, %Array* }*) + +declare %Result* @__quantum__qis__measure__body(%Array*, %Array*) + +define void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__s__body(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__s__body(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__s__adj(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__s__adj(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__s__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__s__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__s__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__s__ctladj(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__Exp__body(%Array* %paulis, double %theta, %Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + call void @__quantum__qis__exp__body(%Array* %paulis, double %theta, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Exp__adj(%Array* %paulis, double %theta, %Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + call void @__quantum__qis__exp__adj(%Array* %paulis, double %theta, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Exp__ctl(%Array* %__controlQubits__, { %Array*, double, %Array* }* %0) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + %1 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 0 + %paulis = load %Array*, %Array** %1, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + %2 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 1 + %theta = load double, double* %2, align 8 + %3 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 2 + %qubits = load %Array*, %Array** %3, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) + %5 = bitcast %Tuple* %4 to { %Array*, double, %Array* }* + %6 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 0 + %7 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 1 + %8 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 2 + store %Array* %paulis, %Array** %6, align 8 + store double %theta, double* %7, align 8 + store %Array* %qubits, %Array** %8, align 8 + call void @__quantum__qis__exp__ctl(%Array* %__controlQubits__, { %Array*, double, %Array* }* %5) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Exp__ctladj(%Array* %__controlQubits__, { %Array*, double, %Array* }* %0) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + %1 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 0 + %paulis = load %Array*, %Array** %1, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + %2 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 1 + %theta = load double, double* %2, align 8 + %3 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 2 + %qubits = load %Array*, %Array** %3, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) + %5 = bitcast %Tuple* %4 to { %Array*, double, %Array* }* + %6 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 0 + %7 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 1 + %8 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 2 + store %Array* %paulis, %Array** %6, align 8 + store double %theta, double* %7, align 8 + store %Array* %qubits, %Array** %8, align 8 + call void @__quantum__qis__exp__ctladj(%Array* %__controlQubits__, { %Array*, double, %Array* }* %5) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__T__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__t__body(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__t__body(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__T__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__t__adj(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__t__adj(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__t__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__t__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__t__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__t__ctladj(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__h__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__h__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__h__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__x__body(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__x__body(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__x__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__x__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__x__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__x__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__R__body(i2 %pauli, double %theta, %Qubit* %qubit) { +entry: + call void @__quantum__qis__r__body(i2 %pauli, double %theta, %Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__r__body(i2, double, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__R__adj(i2 %pauli, double %theta, %Qubit* %qubit) { +entry: + call void @__quantum__qis__r__adj(i2 %pauli, double %theta, %Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__r__adj(i2, double, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__R__ctl(%Array* %__controlQubits__, { i2, double, %Qubit* }* %0) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 + %pauli = load i2, i2* %1, align 1 + %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 + %theta = load double, double* %2, align 8 + %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 + %qubit = load %Qubit*, %Qubit** %3, align 8 + %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) + %5 = bitcast %Tuple* %4 to { i2, double, %Qubit* }* + %6 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 0 + %7 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 1 + %8 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 2 + store i2 %pauli, i2* %6, align 1 + store double %theta, double* %7, align 8 + store %Qubit* %qubit, %Qubit** %8, align 8 + call void @__quantum__qis__r__ctl(%Array* %__controlQubits__, { i2, double, %Qubit* }* %5) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) + ret void +} + +declare void @__quantum__qis__r__ctl(%Array*, { i2, double, %Qubit* }*) + +define void @Microsoft__Quantum__Intrinsic__R__ctladj(%Array* %__controlQubits__, { i2, double, %Qubit* }* %0) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 + %pauli = load i2, i2* %1, align 1 + %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 + %theta = load double, double* %2, align 8 + %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 + %qubit = load %Qubit*, %Qubit** %3, align 8 + %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) + %5 = bitcast %Tuple* %4 to { i2, double, %Qubit* }* + %6 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 0 + %7 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 1 + %8 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 2 + store i2 %pauli, i2* %6, align 1 + store double %theta, double* %7, align 8 + store %Qubit* %qubit, %Qubit** %8, align 8 + call void @__quantum__qis__r__ctladj(%Array* %__controlQubits__, { i2, double, %Qubit* }* %5) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) + ret void +} + +declare void @__quantum__qis__r__ctladj(%Array*, { i2, double, %Qubit* }*) + +define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %bases, %Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +define void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__z__body(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__z__body(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__z__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__z__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__y__body(%Qubit* %qubit) + ret void +} + +declare void @__quantum__qis__y__body(%Qubit*) + +define void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__y__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__qis__y__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__rt__tuple_update_alias_count(%Tuple*, i32) + +attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/test/QIR-dynamic/CMakeLists.txt b/src/QirRuntime/test/QIR-dynamic/CMakeLists.txt index d40bcbd8871..ffdbcaeed53 100644 --- a/src/QirRuntime/test/QIR-dynamic/CMakeLists.txt +++ b/src/QirRuntime/test/QIR-dynamic/CMakeLists.txt @@ -1,12 +1,6 @@ -if (WIN32) - set(TEST_FILES - qir-test-random-win - ) -else() - set(TEST_FILES - qir-test-random-lnx - ) -endif() +set(TEST_FILES + qir-test-random +) foreach(file ${TEST_FILES}) compile_from_qir(${file} "") # don't create a target per file diff --git a/src/QirRuntime/test/QIR-dynamic/qir-test-random-lnx.ll b/src/QirRuntime/test/QIR-dynamic/qir-test-random.ll similarity index 75% rename from src/QirRuntime/test/QIR-dynamic/qir-test-random-lnx.ll rename to src/QirRuntime/test/QIR-dynamic/qir-test-random.ll index cccc97ec31d..5cca945317a 100644 --- a/src/QirRuntime/test/QIR-dynamic/qir-test-random-lnx.ll +++ b/src/QirRuntime/test/QIR-dynamic/qir-test-random.ll @@ -1,11 +1,9 @@ -%Result = type opaque %Range = type { i64, i64, i64 } %Qubit = type opaque +%Result = type opaque %Array = type opaque -@ResultZero = external global %Result* -@ResultOne = external global %Result* @PauliI = constant i2 0 @PauliX = constant i2 1 @PauliY = constant i2 -1 @@ -14,83 +12,10 @@ @Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator = alias i64 (), i64 ()* @Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator__body -define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qb) { -entry: - %bases__inline__1 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases__inline__1, i64 0) - %1 = bitcast i8* %0 to i2* - %2 = load i2, i2* @PauliZ - store i2 %2, i2* %1 - call void @__quantum__rt__array_update_alias_count(%Array* %bases__inline__1, i64 1) - %qubits__inline__1 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %3 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits__inline__1, i64 0) - %4 = bitcast i8* %3 to %Qubit** - store %Qubit* %qb, %Qubit** %4 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits__inline__1, i64 1) - %5 = call %Result* @__quantum__qis__measure__body(%Array* %bases__inline__1, %Array* %qubits__inline__1) - call void @__quantum__rt__array_update_alias_count(%Array* %bases__inline__1, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits__inline__1, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %bases__inline__1, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qubits__inline__1, i64 -1) - ret %Result* %5 -} - -declare %Array* @__quantum__rt__array_create_1d(i32, i64) - -declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) - -declare void @__quantum__rt__array_update_alias_count(%Array*, i64) - -declare %Result* @__quantum__qis__measure__body(%Array*, %Array*) - -declare void @__quantum__rt__array_update_reference_count(%Array*, i64) - -define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %bases, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret %Result* %0 -} - -define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qb) - ret void -} - -declare void @__quantum__qis__h__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -declare void @__quantum__qis__h__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - define i64 @Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator__body() #0 { entry: - %randomNumber = alloca i64 - store i64 0, i64* %randomNumber + %randomNumber = alloca i64, align 8 + store i64 0, i64* %randomNumber, align 4 br label %header__1 header__1: ; preds = %exiting__1, %entry @@ -101,23 +26,23 @@ header__1: ; preds = %exiting__1, %entry body__1: ; preds = %header__1 %q = call %Qubit* @__quantum__rt__qubit_allocate() call void @__quantum__qis__h__body(%Qubit* %q) - %1 = load i64, i64* %randomNumber + %1 = load i64, i64* %randomNumber, align 4 %2 = shl i64 %1, 1 - store i64 %2, i64* %randomNumber + store i64 %2, i64* %randomNumber, align 4 %3 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %q) - %4 = load %Result*, %Result** @ResultOne + %4 = call %Result* @__quantum__rt__result_get_one() %5 = call i1 @__quantum__rt__result_equal(%Result* %3, %Result* %4) br i1 %5, label %then0__1, label %continue__1 then0__1: ; preds = %body__1 - %6 = load i64, i64* %randomNumber + %6 = load i64, i64* %randomNumber, align 4 %7 = add i64 %6, 1 - store i64 %7, i64* %randomNumber + store i64 %7, i64* %randomNumber, align 4 br label %continue__1 continue__1: ; preds = %then0__1, %body__1 + call void @__quantum__rt__result_update_reference_count(%Result* %3, i32 -1) call void @__quantum__rt__qubit_release(%Qubit* %q) - call void @__quantum__rt__result_update_reference_count(%Result* %3, i64 -1) br label %exiting__1 exiting__1: ; preds = %continue__1 @@ -125,7 +50,7 @@ exiting__1: ; preds = %continue__1 br label %header__1 exit__1: ; preds = %header__1 - %9 = load i64, i64* %randomNumber + %9 = load i64, i64* %randomNumber, align 4 ret i64 %9 } @@ -133,10 +58,85 @@ declare %Qubit* @__quantum__rt__qubit_allocate() declare %Array* @__quantum__rt__qubit_allocate_array(i64) +declare void @__quantum__qis__h__body(%Qubit*) + +define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qubit) { +entry: + %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 1) + %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) + %1 = bitcast i8* %0 to i2* + %2 = load i2, i2* @PauliZ, align 1 + store i2 %2, i2* %1, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) + %qubits = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) + %3 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) + %4 = bitcast i8* %3 to %Qubit** + store %Qubit* %qubit, %Qubit** %4, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %5 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %qubits, i32 -1) + ret %Result* %5 +} + +declare %Result* @__quantum__rt__result_get_one() + declare i1 @__quantum__rt__result_equal(%Result*, %Result*) +declare void @__quantum__rt__result_update_reference_count(%Result*, i32) + declare void @__quantum__rt__qubit_release(%Qubit*) -declare void @__quantum__rt__result_update_reference_count(%Result*, i64) +define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__h__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__h__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__rt__array_update_alias_count(%Array*, i32) + +declare void @__quantum__qis__h__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %bases, %Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +declare %Result* @__quantum__qis__measure__body(%Array*, %Array*) + +declare %Array* @__quantum__rt__array_create_1d(i32, i64) + +declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) + +declare void @__quantum__rt__array_update_reference_count(%Array*, i32) attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/test/QIR-dynamic/qsharp/qir-test-random.csproj b/src/QirRuntime/test/QIR-dynamic/qsharp/qir-test-random.csproj new file mode 100644 index 00000000000..5166db5e375 --- /dev/null +++ b/src/QirRuntime/test/QIR-dynamic/qsharp/qir-test-random.csproj @@ -0,0 +1,14 @@ + + + + Exe + netcoreapp3.1 + True + false + + + + + + + diff --git a/src/QirRuntime/test/QIR-dynamic/qir-test-random.qs b/src/QirRuntime/test/QIR-dynamic/qsharp/qir-test-random.qs similarity index 96% rename from src/QirRuntime/test/QIR-dynamic/qir-test-random.qs rename to src/QirRuntime/test/QIR-dynamic/qsharp/qir-test-random.qs index 7e1647bccb9..6a0b2a9787a 100644 --- a/src/QirRuntime/test/QIR-dynamic/qir-test-random.qs +++ b/src/QirRuntime/test/QIR-dynamic/qsharp/qir-test-random.qs @@ -1,25 +1,25 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. - -namespace Microsoft.Quantum.Testing.QIR -{ - open Microsoft.Quantum.Intrinsic; - - @EntryPoint() - operation QuantumRandomNumberGenerator() : Int { - mutable randomNumber = 0; - - for (i in 1 .. 64) - { - using(q = Qubit()) - { - H(q); - set randomNumber = randomNumber <<< 1; - if (M(q) == One) { - set randomNumber += 1; - } - } - } - return randomNumber; - } +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +namespace Microsoft.Quantum.Testing.QIR +{ + open Microsoft.Quantum.Intrinsic; + + @EntryPoint() + operation QuantumRandomNumberGenerator() : Int { + mutable randomNumber = 0; + + for (i in 1 .. 64) + { + using(q = Qubit()) + { + H(q); + set randomNumber = randomNumber <<< 1; + if (M(q) == One) { + set randomNumber += 1; + } + } + } + return randomNumber; + } } \ No newline at end of file diff --git a/src/QirRuntime/test/QIR-dynamic/qir-test-random-win.ll b/src/QirRuntime/test/QIR-dynamic/qsharp/qir/qir-test-random.ll similarity index 75% rename from src/QirRuntime/test/QIR-dynamic/qir-test-random-win.ll rename to src/QirRuntime/test/QIR-dynamic/qsharp/qir/qir-test-random.ll index d83a3f082e4..5cca945317a 100644 --- a/src/QirRuntime/test/QIR-dynamic/qir-test-random-win.ll +++ b/src/QirRuntime/test/QIR-dynamic/qsharp/qir/qir-test-random.ll @@ -1,11 +1,9 @@ -%Result = type opaque %Range = type { i64, i64, i64 } %Qubit = type opaque +%Result = type opaque %Array = type opaque -@ResultZero = external dllimport global %Result* -@ResultOne = external dllimport global %Result* @PauliI = constant i2 0 @PauliX = constant i2 1 @PauliY = constant i2 -1 @@ -14,83 +12,10 @@ @Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator = alias i64 (), i64 ()* @Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator__body -define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qb) { -entry: - %bases__inline__1 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases__inline__1, i64 0) - %1 = bitcast i8* %0 to i2* - %2 = load i2, i2* @PauliZ - store i2 %2, i2* %1 - call void @__quantum__rt__array_update_alias_count(%Array* %bases__inline__1, i64 1) - %qubits__inline__1 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %3 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits__inline__1, i64 0) - %4 = bitcast i8* %3 to %Qubit** - store %Qubit* %qb, %Qubit** %4 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits__inline__1, i64 1) - %5 = call %Result* @__quantum__qis__measure__body(%Array* %bases__inline__1, %Array* %qubits__inline__1) - call void @__quantum__rt__array_update_alias_count(%Array* %bases__inline__1, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits__inline__1, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %bases__inline__1, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qubits__inline__1, i64 -1) - ret %Result* %5 -} - -declare %Array* @__quantum__rt__array_create_1d(i32, i64) - -declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) - -declare void @__quantum__rt__array_update_alias_count(%Array*, i64) - -declare %Result* @__quantum__qis__measure__body(%Array*, %Array*) - -declare void @__quantum__rt__array_update_reference_count(%Array*, i64) - -define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %bases, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret %Result* %0 -} - -define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qb) - ret void -} - -declare void @__quantum__qis__h__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -declare void @__quantum__qis__h__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - define i64 @Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator__body() #0 { entry: - %randomNumber = alloca i64 - store i64 0, i64* %randomNumber + %randomNumber = alloca i64, align 8 + store i64 0, i64* %randomNumber, align 4 br label %header__1 header__1: ; preds = %exiting__1, %entry @@ -101,23 +26,23 @@ header__1: ; preds = %exiting__1, %entry body__1: ; preds = %header__1 %q = call %Qubit* @__quantum__rt__qubit_allocate() call void @__quantum__qis__h__body(%Qubit* %q) - %1 = load i64, i64* %randomNumber + %1 = load i64, i64* %randomNumber, align 4 %2 = shl i64 %1, 1 - store i64 %2, i64* %randomNumber + store i64 %2, i64* %randomNumber, align 4 %3 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %q) - %4 = load %Result*, %Result** @ResultOne + %4 = call %Result* @__quantum__rt__result_get_one() %5 = call i1 @__quantum__rt__result_equal(%Result* %3, %Result* %4) br i1 %5, label %then0__1, label %continue__1 then0__1: ; preds = %body__1 - %6 = load i64, i64* %randomNumber + %6 = load i64, i64* %randomNumber, align 4 %7 = add i64 %6, 1 - store i64 %7, i64* %randomNumber + store i64 %7, i64* %randomNumber, align 4 br label %continue__1 continue__1: ; preds = %then0__1, %body__1 + call void @__quantum__rt__result_update_reference_count(%Result* %3, i32 -1) call void @__quantum__rt__qubit_release(%Qubit* %q) - call void @__quantum__rt__result_update_reference_count(%Result* %3, i64 -1) br label %exiting__1 exiting__1: ; preds = %continue__1 @@ -125,7 +50,7 @@ exiting__1: ; preds = %continue__1 br label %header__1 exit__1: ; preds = %header__1 - %9 = load i64, i64* %randomNumber + %9 = load i64, i64* %randomNumber, align 4 ret i64 %9 } @@ -133,10 +58,85 @@ declare %Qubit* @__quantum__rt__qubit_allocate() declare %Array* @__quantum__rt__qubit_allocate_array(i64) +declare void @__quantum__qis__h__body(%Qubit*) + +define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qubit) { +entry: + %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 1) + %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) + %1 = bitcast i8* %0 to i2* + %2 = load i2, i2* @PauliZ, align 1 + store i2 %2, i2* %1, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) + %qubits = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) + %3 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) + %4 = bitcast i8* %3 to %Qubit** + store %Qubit* %qubit, %Qubit** %4, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %5 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %qubits, i32 -1) + ret %Result* %5 +} + +declare %Result* @__quantum__rt__result_get_one() + declare i1 @__quantum__rt__result_equal(%Result*, %Result*) +declare void @__quantum__rt__result_update_reference_count(%Result*, i32) + declare void @__quantum__rt__qubit_release(%Qubit*) -declare void @__quantum__rt__result_update_reference_count(%Result*, i64) +define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qubit) { +entry: + call void @__quantum__qis__h__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qubit) { +entry: + call void @__quantum__qis__h__body(%Qubit* %qubit) + ret void +} + +define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +declare void @__quantum__rt__array_update_alias_count(%Array*, i32) + +declare void @__quantum__qis__h__ctl(%Array*, %Qubit*) + +define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + ret void +} + +define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %bases, %Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +declare %Result* @__quantum__qis__measure__body(%Array*, %Array*) + +declare %Array* @__quantum__rt__array_create_1d(i32, i64) + +declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) + +declare void @__quantum__rt__array_update_reference_count(%Array*, i32) attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/test/QIR-static/qsharp/qir-gen.csproj b/src/QirRuntime/test/QIR-static/qsharp/qir-gen.csproj index 071e4daa6d5..b061ce01e44 100644 --- a/src/QirRuntime/test/QIR-static/qsharp/qir-gen.csproj +++ b/src/QirRuntime/test/QIR-static/qsharp/qir-gen.csproj @@ -1,4 +1,4 @@ - + Exe diff --git a/src/QirRuntime/test/QIR-tracer/CMakeLists.txt b/src/QirRuntime/test/QIR-tracer/CMakeLists.txt index fb6ab5bd850..dae4001b1d5 100644 --- a/src/QirRuntime/test/QIR-tracer/CMakeLists.txt +++ b/src/QirRuntime/test/QIR-tracer/CMakeLists.txt @@ -1,12 +1,6 @@ -if (WIN32) - set(TEST_FILES - tracer-qir-win - ) -else() - set(TEST_FILES - tracer-qir-lnx - ) -endif() +set(TEST_FILES + tracer-qir +) foreach(file ${TEST_FILES}) compile_from_qir(${file} "") # don't create a target per file diff --git a/src/QirRuntime/test/QIR-tracer/tracer-qir-win.ll b/src/QirRuntime/test/QIR-tracer/qsharp/qir/tracer-qir.ll similarity index 78% rename from src/QirRuntime/test/QIR-tracer/tracer-qir-win.ll rename to src/QirRuntime/test/QIR-tracer/qsharp/qir/tracer-qir.ll index c53abaa2d2e..0bf147d470f 100644 --- a/src/QirRuntime/test/QIR-tracer/tracer-qir-win.ll +++ b/src/QirRuntime/test/QIR-tracer/qsharp/qir/tracer-qir.ll @@ -1,14 +1,12 @@ -%Result = type opaque %Range = type { i64, i64, i64 } %Tuple = type opaque +%Result = type opaque +%Qubit = type opaque %Array = type opaque %Callable = type opaque -%Qubit = type opaque %String = type opaque -@ResultZero = external dllimport global %Result* -@ResultOne = external dllimport global %Result* @PauliI = constant i2 0 @PauliX = constant i2 1 @PauliY = constant i2 -1 @@ -17,63 +15,227 @@ @Microsoft__Quantum__Testing__Tracer__Delay = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Testing__Tracer__Delay__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] @Microsoft__Quantum__Intrinsic__X = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper] @PartialApplication__1 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@MemoryManagement__1 = constant [2 x void (%Tuple*, i64)*] [void (%Tuple*, i64)* @MemoryManagement__1__RefCount, void (%Tuple*, i64)* @MemoryManagement__1__AliasCount] +@MemoryManagement__1 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__1__RefCount, void (%Tuple*, i32)* @MemoryManagement__1__AliasCount] @Microsoft__Quantum__Intrinsic__Y = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper] @PartialApplication__2 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__2__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] @Microsoft__Quantum__Intrinsic__Z = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper] @PartialApplication__3 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__3__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] @Microsoft__Quantum__Intrinsic__S = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper] @PartialApplication__4 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__4__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@MemoryManagement__2 = constant [2 x void (%Tuple*, i64)*] [void (%Tuple*, i64)* @MemoryManagement__2__RefCount, void (%Tuple*, i64)* @MemoryManagement__2__AliasCount] +@MemoryManagement__2 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__2__RefCount, void (%Tuple*, i32)* @MemoryManagement__2__AliasCount] + +define %Result* @Microsoft__Quantum__Instructions__Mx__body(%Qubit* %qb) { +entry: + %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb) + ret %Result* %0 +} + +declare %Result* @__quantum__qis__single_qubit_measure(i64, i64, %Qubit*) + +define %Result* @Microsoft__Quantum__Instructions__Mxx__body(%Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +declare void @__quantum__rt__array_update_alias_count(%Array*, i32) + +declare %Result* @__quantum__qis__joint_measure(i64, i64, %Array*) + +define %Result* @Microsoft__Quantum__Instructions__Mxz__body(%Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +define %Result* @Microsoft__Quantum__Instructions__Mz__body(%Qubit* %qb) { +entry: + %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb) + ret %Result* %0 +} + +define %Result* @Microsoft__Quantum__Instructions__Mzx__body(%Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +define %Result* @Microsoft__Quantum__Instructions__Mzz__body(%Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +define void @Microsoft__Quantum__Instructions__Sx__body(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) + ret void +} + +declare void @__quantum__qis__single_qubit_op(i64, i64, %Qubit*) + +define void @Microsoft__Quantum__Instructions__Sx__adj(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Sx__ctl(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +declare void @__quantum__qis__single_qubit_op_ctl(i64, i64, %Array*, %Qubit*) + +define void @Microsoft__Quantum__Instructions__Sx__ctladj(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Sz__body(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Sz__adj(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Sz__ctl(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Sz__ctladj(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tx__body(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tx__adj(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tx__ctl(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tx__ctladj(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tz__body(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tz__adj(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tz__ctl(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tz__ctladj(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} define void @Microsoft__Quantum__Intrinsic__ApplyConditionallyIntrinsic__body(%Array* %measurementResults, %Array* %resultsValues, %Callable* %onEqualOp, %Callable* %onNonEqualOp) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i64 1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onEqualOp, i64 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i64 1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onNonEqualOp, i64 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i32 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onEqualOp, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i32 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onNonEqualOp, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i32 1) call void @__quantum__qis__apply_conditionally(%Array* %measurementResults, %Array* %resultsValues, %Callable* %onEqualOp, %Callable* %onNonEqualOp) - call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onEqualOp, i64 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onNonEqualOp, i64 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i32 -1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onEqualOp, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i32 -1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onNonEqualOp, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i32 -1) ret void } -declare void @__quantum__rt__array_update_alias_count(%Array*, i64) - -declare void @__quantum__rt__callable_memory_management(i32, %Callable*, i64) +declare void @__quantum__rt__capture_update_alias_count(%Callable*, i32) -declare void @__quantum__rt__callable_update_alias_count(%Callable*, i64) +declare void @__quantum__rt__callable_update_alias_count(%Callable*, i32) declare void @__quantum__qis__apply_conditionally(%Array*, %Array*, %Callable*, %Callable*) define void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %measurementResult, %Callable* %onResultZeroOp, %Callable* %onResultOneOp) { entry: - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onResultZeroOp, i64 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i64 1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onResultOneOp, i64 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i64 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultZeroOp, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i32 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultOneOp, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i32 1) %0 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %1 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %0, i64 0) %2 = bitcast i8* %1 to %Result** - store %Result* %measurementResult, %Result** %2 + store %Result* %measurementResult, %Result** %2, align 8 %3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 0) %5 = bitcast i8* %4 to %Result** - %6 = load %Result*, %Result** @ResultZero - store %Result* %6, %Result** %5 + %6 = call %Result* @__quantum__rt__result_get_zero() + store %Result* %6, %Result** %5, align 8 call void @__quantum__qis__apply_conditionally(%Array* %0, %Array* %3, %Callable* %onResultZeroOp, %Callable* %onResultOneOp) - call void @__quantum__rt__result_update_reference_count(%Result* %measurementResult, i64 1) - call void @__quantum__rt__result_update_reference_count(%Result* %6, i64 1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onResultZeroOp, i64 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onResultOneOp, i64 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %measurementResult, i32 1) + call void @__quantum__rt__result_update_reference_count(%Result* %6, i32 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultZeroOp, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i32 -1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultOneOp, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i32 -1) br label %header__1 header__1: ; preds = %exiting__1, %entry @@ -84,8 +246,8 @@ header__1: ; preds = %exiting__1, %entry body__1: ; preds = %header__1 %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %0, i64 %7) %10 = bitcast i8* %9 to %Result** - %11 = load %Result*, %Result** %10 - call void @__quantum__rt__result_update_reference_count(%Result* %11, i64 -1) + %11 = load %Result*, %Result** %10, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %11, i32 -1) br label %exiting__1 exiting__1: ; preds = %body__1 @@ -93,7 +255,7 @@ exiting__1: ; preds = %body__1 br label %header__1 exit__1: ; preds = %header__1 - call void @__quantum__rt__array_update_reference_count(%Array* %0, i64 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %0, i32 -1) br label %header__2 header__2: ; preds = %exiting__2, %exit__1 @@ -104,8 +266,8 @@ header__2: ; preds = %exiting__2, %exit__ body__2: ; preds = %header__2 %15 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 %13) %16 = bitcast i8* %15 to %Result** - %17 = load %Result*, %Result** %16 - call void @__quantum__rt__result_update_reference_count(%Result* %17, i64 -1) + %17 = load %Result*, %Result** %16, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 -1) br label %exiting__2 exiting__2: ; preds = %body__2 @@ -113,7 +275,7 @@ exiting__2: ; preds = %body__2 br label %header__2 exit__2: ; preds = %header__2 - call void @__quantum__rt__array_update_reference_count(%Array* %3, i64 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %3, i32 -1) ret void } @@ -121,17 +283,19 @@ declare %Array* @__quantum__rt__array_create_1d(i32, i64) declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) -declare void @__quantum__rt__result_update_reference_count(%Result*, i64) +declare %Result* @__quantum__rt__result_get_zero() -declare void @__quantum__rt__array_update_reference_count(%Array*, i64) +declare void @__quantum__rt__result_update_reference_count(%Result*, i32) + +declare void @__quantum__rt__array_update_reference_count(%Array*, i32) define void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %control, %Qubit* %target) { entry: %ctls = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) %1 = bitcast i8* %0 to %Qubit** - store %Qubit* %control, %Qubit** %1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + store %Qubit* %control, %Qubit** %1, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) br i1 true, label %then0__1, label %else__1 then0__1: ; preds = %entry @@ -143,13 +307,11 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i32 -1) ret void } -declare void @__quantum__qis__single_qubit_op_ctl(i64, i64, %Array*, %Qubit*) - define void @Microsoft__Quantum__Intrinsic__CNOT__adj(%Qubit* %control, %Qubit* %target) { entry: call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %control, %Qubit* %target) @@ -158,17 +320,17 @@ entry: define void @Microsoft__Quantum__Intrinsic__CNOT__ctl(%Array* %ctls, { %Qubit*, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 0 - %control = load %Qubit*, %Qubit** %1 + %control = load %Qubit*, %Qubit** %1, align 8 %2 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 1 - %target = load %Qubit*, %Qubit** %2 + %target = load %Qubit*, %Qubit** %2, align 8 %3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 0) %5 = bitcast i8* %4 to %Qubit** - store %Qubit* %control, %Qubit** %5 + store %Qubit* %control, %Qubit** %5, align 8 %ctls__1 = call %Array* @__quantum__rt__array_concatenate(%Array* %ctls, %Array* %3) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 1) %6 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls__1) %7 = icmp eq i64 %6, 1 br i1 %7, label %then0__1, label %else__1 @@ -182,10 +344,10 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %3, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %3, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -195,26 +357,26 @@ declare i64 @__quantum__rt__array_get_size_1d(%Array*) define void @Microsoft__Quantum__Intrinsic__CNOT__ctladj(%Array* %__controlQubits__, { %Qubit*, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) %1 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 0 - %control = load %Qubit*, %Qubit** %1 + %control = load %Qubit*, %Qubit** %1, align 8 %2 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 1 - %target = load %Qubit*, %Qubit** %2 + %target = load %Qubit*, %Qubit** %2, align 8 %3 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) %4 = bitcast %Tuple* %3 to { %Qubit*, %Qubit* }* %5 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %4, i32 0, i32 0 %6 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %4, i32 0, i32 1 - store %Qubit* %control, %Qubit** %5 - store %Qubit* %target, %Qubit** %6 + store %Qubit* %control, %Qubit** %5, align 8 + store %Qubit* %target, %Qubit** %6, align 8 call void @Microsoft__Quantum__Intrinsic__CNOT__ctl(%Array* %__controlQubits__, { %Qubit*, %Qubit* }* %4) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %3, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %3, i32 -1) ret void } declare %Tuple* @__quantum__rt__tuple_create(i64) -declare void @__quantum__rt__tuple_update_reference_count(%Tuple*, i64) +declare void @__quantum__rt__tuple_update_reference_count(%Tuple*, i32) define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qb) { entry: @@ -222,8 +384,6 @@ entry: ret void } -declare void @__quantum__qis__single_qubit_op(i64, i64, %Qubit*) - define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qb) { entry: call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb) @@ -232,19 +392,19 @@ entry: define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) ret void } @@ -254,18 +414,16 @@ entry: ret %Result* %0 } -declare %Result* @__quantum__qis__single_qubit_measure(i64, i64, %Qubit*) - define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %paulis, %Array* %qubits) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = load %Result*, %Result** @ResultOne - %res = alloca %Result* - store %Result* %0, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %0, i64 1) - %haveY = alloca i1 - store i1 false, i1* %haveY + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__rt__result_get_one() + %res = alloca %Result*, align 8 + store %Result* %0, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %0, i32 1) + %haveY = alloca i1, align 1 + store i1 false, i1* %haveY, align 1 %1 = call i64 @__quantum__rt__array_get_size_1d(%Array* %paulis) %2 = sub i64 %1, 1 br label %header__1 @@ -278,22 +436,28 @@ header__1: ; preds = %exiting__1, %entry body__1: ; preds = %header__1 %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) %5 = bitcast i8* %4 to i2* - %6 = load i2, i2* %5 - %7 = load i2, i2* @PauliY + %6 = load i2, i2* %5, align 1 + %7 = load i2, i2* @PauliY, align 1 %8 = icmp eq i2 %6, %7 + br i1 %8, label %condContinue__1, label %condFalse__1 + +condFalse__1: ; preds = %body__1 %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) %10 = bitcast i8* %9 to i2* - %11 = load i2, i2* %10 - %12 = load i2, i2* @PauliI + %11 = load i2, i2* %10, align 1 + %12 = load i2, i2* @PauliI, align 1 %13 = icmp eq i2 %11, %12 - %14 = or i1 %8, %13 + br label %condContinue__1 + +condContinue__1: ; preds = %condFalse__1, %body__1 + %14 = phi i1 [ %8, %body__1 ], [ %13, %condFalse__1 ] br i1 %14, label %then0__1, label %continue__1 -then0__1: ; preds = %body__1 - store i1 true, i1* %haveY +then0__1: ; preds = %condContinue__1 + store i1 true, i1* %haveY, align 1 br label %continue__1 -continue__1: ; preds = %then0__1, %body__1 +continue__1: ; preds = %then0__1, %condContinue__1 br label %exiting__1 exiting__1: ; preds = %continue__1 @@ -301,15 +465,15 @@ exiting__1: ; preds = %continue__1 br label %header__1 exit__1: ; preds = %header__1 - %16 = load i1, i1* %haveY + %16 = load i1, i1* %haveY, align 1 br i1 %16, label %then0__2, label %test1__1 then0__2: ; preds = %exit__1 %17 = call %Result* @__quantum__qis__joint_measure(i64 106, i64 1, %Array* %qubits) - call void @__quantum__rt__result_update_reference_count(%Result* %17, i64 1) - store %Result* %17, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %17, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %0, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 1) + store %Result* %17, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %0, i32 -1) br label %continue__2 test1__1: ; preds = %exit__1 @@ -318,11 +482,11 @@ test1__1: ; preds = %exit__1 then1__1: ; preds = %test1__1 %19 = call %Result* @__quantum__qis__joint_measure(i64 107, i64 1, %Array* %qubits) - call void @__quantum__rt__result_update_reference_count(%Result* %19, i64 1) - %20 = load %Result*, %Result** %res - store %Result* %19, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %19, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %20, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %19, i32 1) + %20 = load %Result*, %Result** %res, align 8 + store %Result* %19, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %19, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %20, i32 -1) br label %continue__2 test2__1: ; preds = %test1__1 @@ -332,33 +496,33 @@ test2__1: ; preds = %test1__1 then2__1: ; preds = %test2__1 %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %23 = bitcast i8* %22 to i2* - %24 = load i2, i2* %23 - %25 = load i2, i2* @PauliX + %24 = load i2, i2* %23, align 1 + %25 = load i2, i2* @PauliX, align 1 %26 = icmp eq i2 %24, %25 br i1 %26, label %then0__3, label %else__1 then0__3: ; preds = %then2__1 %27 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) %28 = bitcast i8* %27 to %Qubit** - %qb = load %Qubit*, %Qubit** %28 + %qb = load %Qubit*, %Qubit** %28, align 8 %29 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb) - call void @__quantum__rt__result_update_reference_count(%Result* %29, i64 1) - %30 = load %Result*, %Result** %res - store %Result* %29, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %29, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %30, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %29, i32 1) + %30 = load %Result*, %Result** %res, align 8 + store %Result* %29, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %29, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %30, i32 -1) br label %continue__3 else__1: ; preds = %then2__1 %31 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) %32 = bitcast i8* %31 to %Qubit** - %qb__1 = load %Qubit*, %Qubit** %32 + %qb__1 = load %Qubit*, %Qubit** %32, align 8 %33 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__1) - call void @__quantum__rt__result_update_reference_count(%Result* %33, i64 1) - %34 = load %Result*, %Result** %res - store %Result* %33, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %33, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %34, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %33, i32 1) + %34 = load %Result*, %Result** %res, align 8 + store %Result* %33, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %33, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %34, i32 -1) br label %continue__3 continue__3: ; preds = %else__1, %then0__3 @@ -367,111 +531,135 @@ continue__3: ; preds = %else__1, %then0__3 test3__1: ; preds = %test2__1 %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %36 = bitcast i8* %35 to i2* - %37 = load i2, i2* %36 - %38 = load i2, i2* @PauliX + %37 = load i2, i2* %36, align 1 + %38 = load i2, i2* @PauliX, align 1 %39 = icmp eq i2 %37, %38 + br i1 %39, label %condTrue__1, label %condContinue__2 + +condTrue__1: ; preds = %test3__1 %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %41 = bitcast i8* %40 to i2* - %42 = load i2, i2* %41 - %43 = load i2, i2* @PauliX + %42 = load i2, i2* %41, align 1 + %43 = load i2, i2* @PauliX, align 1 %44 = icmp eq i2 %42, %43 - %45 = and i1 %39, %44 + br label %condContinue__2 + +condContinue__2: ; preds = %condTrue__1, %test3__1 + %45 = phi i1 [ %44, %condTrue__1 ], [ %39, %test3__1 ] br i1 %45, label %then3__1, label %test4__1 -then3__1: ; preds = %test3__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) +then3__1: ; preds = %condContinue__2 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) %46 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %46, i64 1) - %47 = load %Result*, %Result** %res - store %Result* %46, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %46, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %47, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %46, i32 1) + %47 = load %Result*, %Result** %res, align 8 + store %Result* %46, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %46, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %47, i32 -1) br label %continue__2 -test4__1: ; preds = %test3__1 +test4__1: ; preds = %condContinue__2 %48 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %49 = bitcast i8* %48 to i2* - %50 = load i2, i2* %49 - %51 = load i2, i2* @PauliX + %50 = load i2, i2* %49, align 1 + %51 = load i2, i2* @PauliX, align 1 %52 = icmp eq i2 %50, %51 + br i1 %52, label %condTrue__2, label %condContinue__3 + +condTrue__2: ; preds = %test4__1 %53 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %54 = bitcast i8* %53 to i2* - %55 = load i2, i2* %54 - %56 = load i2, i2* @PauliZ + %55 = load i2, i2* %54, align 1 + %56 = load i2, i2* @PauliZ, align 1 %57 = icmp eq i2 %55, %56 - %58 = and i1 %52, %57 + br label %condContinue__3 + +condContinue__3: ; preds = %condTrue__2, %test4__1 + %58 = phi i1 [ %57, %condTrue__2 ], [ %52, %test4__1 ] br i1 %58, label %then4__1, label %test5__1 -then4__1: ; preds = %test4__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) +then4__1: ; preds = %condContinue__3 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) %59 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %59, i64 1) - %60 = load %Result*, %Result** %res - store %Result* %59, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %59, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %60, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %59, i32 1) + %60 = load %Result*, %Result** %res, align 8 + store %Result* %59, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %59, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %60, i32 -1) br label %continue__2 -test5__1: ; preds = %test4__1 +test5__1: ; preds = %condContinue__3 %61 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %62 = bitcast i8* %61 to i2* - %63 = load i2, i2* %62 - %64 = load i2, i2* @PauliZ + %63 = load i2, i2* %62, align 1 + %64 = load i2, i2* @PauliZ, align 1 %65 = icmp eq i2 %63, %64 + br i1 %65, label %condTrue__3, label %condContinue__4 + +condTrue__3: ; preds = %test5__1 %66 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %67 = bitcast i8* %66 to i2* - %68 = load i2, i2* %67 - %69 = load i2, i2* @PauliX + %68 = load i2, i2* %67, align 1 + %69 = load i2, i2* @PauliX, align 1 %70 = icmp eq i2 %68, %69 - %71 = and i1 %65, %70 + br label %condContinue__4 + +condContinue__4: ; preds = %condTrue__3, %test5__1 + %71 = phi i1 [ %70, %condTrue__3 ], [ %65, %test5__1 ] br i1 %71, label %then5__1, label %test6__1 -then5__1: ; preds = %test5__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) +then5__1: ; preds = %condContinue__4 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) %72 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %72, i64 1) - %73 = load %Result*, %Result** %res - store %Result* %72, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %72, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %73, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %72, i32 1) + %73 = load %Result*, %Result** %res, align 8 + store %Result* %72, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %72, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %73, i32 -1) br label %continue__2 -test6__1: ; preds = %test5__1 +test6__1: ; preds = %condContinue__4 %74 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %75 = bitcast i8* %74 to i2* - %76 = load i2, i2* %75 - %77 = load i2, i2* @PauliZ + %76 = load i2, i2* %75, align 1 + %77 = load i2, i2* @PauliZ, align 1 %78 = icmp eq i2 %76, %77 + br i1 %78, label %condTrue__4, label %condContinue__5 + +condTrue__4: ; preds = %test6__1 %79 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %80 = bitcast i8* %79 to i2* - %81 = load i2, i2* %80 - %82 = load i2, i2* @PauliZ + %81 = load i2, i2* %80, align 1 + %82 = load i2, i2* @PauliZ, align 1 %83 = icmp eq i2 %81, %82 - %84 = and i1 %78, %83 + br label %condContinue__5 + +condContinue__5: ; preds = %condTrue__4, %test6__1 + %84 = phi i1 [ %83, %condTrue__4 ], [ %78, %test6__1 ] br i1 %84, label %then6__1, label %continue__2 -then6__1: ; preds = %test6__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) +then6__1: ; preds = %condContinue__5 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) %85 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %85, i64 1) - %86 = load %Result*, %Result** %res - store %Result* %85, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %85, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %86, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %85, i32 1) + %86 = load %Result*, %Result** %res, align 8 + store %Result* %85, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %85, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %86, i32 -1) br label %continue__2 -continue__2: ; preds = %then6__1, %test6__1, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 - %87 = load %Result*, %Result** %res - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) +continue__2: ; preds = %then6__1, %condContinue__5, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 + %87 = load %Result*, %Result** %res, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) ret %Result* %87 } -declare %Result* @__quantum__qis__joint_measure(i64, i64, %Array*) +declare %Result* @__quantum__rt__result_get_one() define void @Microsoft__Quantum__Intrinsic__Rx__body(double %theta, %Qubit* %qb) { entry: @@ -487,25 +675,25 @@ entry: define void @Microsoft__Quantum__Intrinsic__Rx__ctl(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__Rx__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -523,25 +711,25 @@ entry: define void @Microsoft__Quantum__Intrinsic__Ry__ctl(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__Ry__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -559,25 +747,25 @@ entry: define void @Microsoft__Quantum__Intrinsic__Rz__ctl(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__Rz__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -595,21 +783,21 @@ entry: define void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -627,21 +815,21 @@ entry: define void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -659,7 +847,7 @@ entry: define void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -673,14 +861,14 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -694,8 +882,8 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) ret void } @@ -713,7 +901,7 @@ entry: define void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -727,14 +915,14 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -748,8 +936,8 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) ret void } @@ -767,7 +955,7 @@ entry: define void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -781,14 +969,14 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -802,194 +990,23 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -define %Tuple* @Microsoft__Quantum__Core__Attribute__body() { -entry: - ret %Tuple* null -} - -define %Tuple* @Microsoft__Quantum__Core__EntryPoint__body() { -entry: - ret %Tuple* null -} - -define %Tuple* @Microsoft__Quantum__Core__Inline__body() { -entry: - ret %Tuple* null -} - -define %Result* @Microsoft__Quantum__Instructions__Mx__body(%Qubit* %qb) { -entry: - %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mxx__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mxz__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mz__body(%Qubit* %qb) { -entry: - %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mzx__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mzz__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret %Result* %0 -} - -define void @Microsoft__Quantum__Instructions__Sx__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sx__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sx__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sx__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) ret void } define void @Microsoft__Quantum__Testing__Tracer__Delay__body(%Callable* %op, %Qubit* %arg, %Tuple* %aux) { entry: - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %op, i64 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i64 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 1) %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) %1 = bitcast %Tuple* %0 to { %Qubit* }* %2 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %1, i32 0, i32 0 - store %Qubit* %arg, %Qubit** %2 + store %Qubit* %arg, %Qubit** %2, align 8 call void @__quantum__rt__callable_invoke(%Callable* %op, %Tuple* %0, %Tuple* null) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %op, i64 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %0, i64 -1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %0, i32 -1) ret void } @@ -998,103 +1015,103 @@ declare void @__quantum__rt__callable_invoke(%Callable*, %Tuple*, %Tuple*) define void @Microsoft__Quantum__Testing__Tracer__TestCoreIntrinsics__body() { entry: %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 3) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %1 = bitcast i8* %0 to %Qubit** - %qb = load %Qubit*, %Qubit** %1 + %qb = load %Qubit*, %Qubit** %1, align 8 call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb) %2 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %3 = bitcast i8* %2 to %Qubit** - %qb__1 = load %Qubit*, %Qubit** %3 + %qb__1 = load %Qubit*, %Qubit** %3, align 8 call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb__1) %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %5 = bitcast i8* %4 to %Qubit** - %qb__2 = load %Qubit*, %Qubit** %5 + %qb__2 = load %Qubit*, %Qubit** %5, align 8 call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb__2) %6 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %7 = bitcast i8* %6 to %Qubit** - %qb__3 = load %Qubit*, %Qubit** %7 + %qb__3 = load %Qubit*, %Qubit** %7, align 8 call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb__3) %8 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %9 = bitcast i8* %8 to %Qubit** - %10 = load %Qubit*, %Qubit** %9 + %10 = load %Qubit*, %Qubit** %9, align 8 %11 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %12 = bitcast i8* %11 to %Qubit** - %13 = load %Qubit*, %Qubit** %12 + %13 = load %Qubit*, %Qubit** %12, align 8 call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %10, %Qubit* %13) %14 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %15 = bitcast i8* %14 to %Qubit** - %qb__4 = load %Qubit*, %Qubit** %15 + %qb__4 = load %Qubit*, %Qubit** %15, align 8 call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__4) %16 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %17 = bitcast i8* %16 to %Qubit** - %qb__5 = load %Qubit*, %Qubit** %17 + %qb__5 = load %Qubit*, %Qubit** %17, align 8 call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb__5) %18 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %19 = bitcast i8* %18 to %Qubit** - %qb__6 = load %Qubit*, %Qubit** %19 + %qb__6 = load %Qubit*, %Qubit** %19, align 8 call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb__6) %20 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %21 = bitcast i8* %20 to %Qubit** - %qb__7 = load %Qubit*, %Qubit** %21 + %qb__7 = load %Qubit*, %Qubit** %21, align 8 call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb__7) %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %23 = bitcast i8* %22 to %Qubit** - %qb__9 = load %Qubit*, %Qubit** %23 + %qb__9 = load %Qubit*, %Qubit** %23, align 8 call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__9) call void @__quantum__qis__inject_barrier(i64 42, i64 0) %24 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %25 = bitcast i8* %24 to %Qubit** - %qb__11 = load %Qubit*, %Qubit** %25 + %qb__11 = load %Qubit*, %Qubit** %25, align 8 call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb__11) %26 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %27 = bitcast i8* %26 to %Qubit** - %qb__13 = load %Qubit*, %Qubit** %27 + %qb__13 = load %Qubit*, %Qubit** %27, align 8 call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb__13) %28 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %29 = bitcast i8* %28 to %Qubit** - %qb__15 = load %Qubit*, %Qubit** %29 + %qb__15 = load %Qubit*, %Qubit** %29, align 8 call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb__15) %30 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %31 = bitcast i8* %30 to %Qubit** - %qb__17 = load %Qubit*, %Qubit** %31 + %qb__17 = load %Qubit*, %Qubit** %31, align 8 call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb__17) %32 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %33 = bitcast i8* %32 to %Qubit** - %34 = load %Qubit*, %Qubit** %33 + %34 = load %Qubit*, %Qubit** %33, align 8 %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %36 = bitcast i8* %35 to %Qubit** - %37 = load %Qubit*, %Qubit** %36 + %37 = load %Qubit*, %Qubit** %36, align 8 call void @Microsoft__Quantum__Intrinsic__CNOT__adj(%Qubit* %34, %Qubit* %37) %38 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %39 = bitcast i8* %38 to %Qubit** - %qb__19 = load %Qubit*, %Qubit** %39 + %qb__19 = load %Qubit*, %Qubit** %39, align 8 call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__19) %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %41 = bitcast i8* %40 to %Qubit** - %qb__20 = load %Qubit*, %Qubit** %41 + %qb__20 = load %Qubit*, %Qubit** %41, align 8 call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb__20) %42 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %43 = bitcast i8* %42 to %Qubit** - %qb__21 = load %Qubit*, %Qubit** %43 + %qb__21 = load %Qubit*, %Qubit** %43, align 8 call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb__21) %44 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %45 = bitcast i8* %44 to %Qubit** - %qb__22 = load %Qubit*, %Qubit** %45 + %qb__22 = load %Qubit*, %Qubit** %45, align 8 call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb__22) %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %47 = bitcast i8* %46 to %Qubit** - %qb__24 = load %Qubit*, %Qubit** %47 + %qb__24 = load %Qubit*, %Qubit** %47, align 8 call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__24) %c = call %Qubit* @__quantum__rt__qubit_allocate() %ctls = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %48 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) %49 = bitcast i8* %48 to %Qubit** - store %Qubit* %c, %Qubit** %49 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + store %Qubit* %c, %Qubit** %49, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %50 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %51 = bitcast i8* %50 to %Qubit** - %qb__26 = load %Qubit*, %Qubit** %51 + %qb__26 = load %Qubit*, %Qubit** %51, align 8 br i1 true, label %then0__1, label %else__1 then0__1: ; preds = %entry @@ -1106,16 +1123,16 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i32 -1) %ctls__1 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %52 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__1, i64 0) %53 = bitcast i8* %52 to %Qubit** - store %Qubit* %c, %Qubit** %53 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i64 1) + store %Qubit* %c, %Qubit** %53, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 1) %54 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %55 = bitcast i8* %54 to %Qubit** - %qb__27 = load %Qubit*, %Qubit** %55 + %qb__27 = load %Qubit*, %Qubit** %55, align 8 br i1 true, label %then0__2, label %else__2 then0__2: ; preds = %continue__1 @@ -1127,16 +1144,16 @@ else__2: ; preds = %continue__1 br label %continue__2 continue__2: ; preds = %else__2, %then0__2 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i32 -1) %ctls__2 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %56 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__2, i64 0) %57 = bitcast i8* %56 to %Qubit** - store %Qubit* %c, %Qubit** %57 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i64 1) + store %Qubit* %c, %Qubit** %57, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i32 1) %58 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %59 = bitcast i8* %58 to %Qubit** - %qb__28 = load %Qubit*, %Qubit** %59 + %qb__28 = load %Qubit*, %Qubit** %59, align 8 br i1 true, label %then0__3, label %else__3 then0__3: ; preds = %continue__2 @@ -1148,85 +1165,85 @@ else__3: ; preds = %continue__2 br label %continue__3 continue__3: ; preds = %else__3, %then0__3 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__2, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__2, i32 -1) %ctls__3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %60 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__3, i64 0) %61 = bitcast i8* %60 to %Qubit** - store %Qubit* %c, %Qubit** %61 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i64 1) + store %Qubit* %c, %Qubit** %61, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i32 1) %62 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %63 = bitcast i8* %62 to %Qubit** - %qb__29 = load %Qubit*, %Qubit** %63 + %qb__29 = load %Qubit*, %Qubit** %63, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %ctls__3, %Qubit* %qb__29) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__3, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__3, i32 -1) %ctls__4 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %64 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__4, i64 0) %65 = bitcast i8* %64 to %Qubit** - store %Qubit* %c, %Qubit** %65 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i64 1) + store %Qubit* %c, %Qubit** %65, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i32 1) %66 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %67 = bitcast i8* %66 to %Qubit** - %qb__30 = load %Qubit*, %Qubit** %67 + %qb__30 = load %Qubit*, %Qubit** %67, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls__4, %Qubit* %qb__30) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__4, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__4, i32 -1) %ctls__5 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %68 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__5, i64 0) %69 = bitcast i8* %68 to %Qubit** - store %Qubit* %c, %Qubit** %69 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i64 1) + store %Qubit* %c, %Qubit** %69, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i32 1) %70 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %71 = bitcast i8* %70 to %Qubit** - %qb__31 = load %Qubit*, %Qubit** %71 + %qb__31 = load %Qubit*, %Qubit** %71, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls__5, %Qubit* %qb__31) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__5, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__5, i32 -1) %ctls__6 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %72 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__6, i64 0) %73 = bitcast i8* %72 to %Qubit** - store %Qubit* %c, %Qubit** %73 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i64 1) + store %Qubit* %c, %Qubit** %73, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i32 1) %74 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %75 = bitcast i8* %74 to %Qubit** - %qb__32 = load %Qubit*, %Qubit** %75 + %qb__32 = load %Qubit*, %Qubit** %75, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls__6, %Qubit* %qb__32) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__6, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__6, i32 -1) %ctls__7 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %76 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__7, i64 0) %77 = bitcast i8* %76 to %Qubit** - store %Qubit* %c, %Qubit** %77 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i64 1) + store %Qubit* %c, %Qubit** %77, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 1) %78 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %79 = bitcast i8* %78 to %Qubit** - %qb__33 = load %Qubit*, %Qubit** %79 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i64 1) + %qb__33 = load %Qubit*, %Qubit** %79, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls__7, %Qubit* %qb__33) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__7, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__7, i32 -1) %ctls__9 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %80 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__9, i64 0) %81 = bitcast i8* %80 to %Qubit** - store %Qubit* %c, %Qubit** %81 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i64 1) + store %Qubit* %c, %Qubit** %81, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 1) %82 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %83 = bitcast i8* %82 to %Qubit** - %qb__35 = load %Qubit*, %Qubit** %83 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i64 1) + %qb__35 = load %Qubit*, %Qubit** %83, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls__9, %Qubit* %qb__35) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__9, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__9, i32 -1) call void @__quantum__rt__qubit_release(%Qubit* %c) %cc = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %84 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %85 = bitcast i8* %84 to %Qubit** - %qb__37 = load %Qubit*, %Qubit** %85 + %qb__37 = load %Qubit*, %Qubit** %85, align 8 %86 = call i64 @__quantum__rt__array_get_size_1d(%Array* %cc) %87 = icmp eq i64 %86, 1 br i1 %87, label %then0__4, label %else__4 @@ -1240,11 +1257,11 @@ else__4: ; preds = %continue__3 br label %continue__4 continue__4: ; preds = %else__4, %then0__4 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %88 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %89 = bitcast i8* %88 to %Qubit** - %qb__38 = load %Qubit*, %Qubit** %89 + %qb__38 = load %Qubit*, %Qubit** %89, align 8 %90 = icmp eq i64 %86, 1 br i1 %90, label %then0__5, label %else__5 @@ -1257,11 +1274,11 @@ else__5: ; preds = %continue__4 br label %continue__5 continue__5: ; preds = %else__5, %then0__5 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %91 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %92 = bitcast i8* %91 to %Qubit** - %qb__39 = load %Qubit*, %Qubit** %92 + %qb__39 = load %Qubit*, %Qubit** %92, align 8 %93 = icmp eq i64 %86, 1 br i1 %93, label %then0__6, label %else__6 @@ -1274,53 +1291,51 @@ else__6: ; preds = %continue__5 br label %continue__6 continue__6: ; preds = %else__6, %then0__6 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %94 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %95 = bitcast i8* %94 to %Qubit** - %qb__40 = load %Qubit*, %Qubit** %95 + %qb__40 = load %Qubit*, %Qubit** %95, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %cc, %Qubit* %qb__40) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %96 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %97 = bitcast i8* %96 to %Qubit** - %qb__41 = load %Qubit*, %Qubit** %97 + %qb__41 = load %Qubit*, %Qubit** %97, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %cc, %Qubit* %qb__41) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %98 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %99 = bitcast i8* %98 to %Qubit** - %qb__42 = load %Qubit*, %Qubit** %99 + %qb__42 = load %Qubit*, %Qubit** %99, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %cc, %Qubit* %qb__42) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %100 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %101 = bitcast i8* %100 to %Qubit** - %qb__43 = load %Qubit*, %Qubit** %101 + %qb__43 = load %Qubit*, %Qubit** %101, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %cc, %Qubit* %qb__43) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %102 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %103 = bitcast i8* %102 to %Qubit** - %qb__44 = load %Qubit*, %Qubit** %103 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + %qb__44 = load %Qubit*, %Qubit** %103, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %cc, %Qubit* %qb__44) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %104 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %105 = bitcast i8* %104 to %Qubit** - %qb__46 = load %Qubit*, %Qubit** %105 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + %qb__46 = load %Qubit*, %Qubit** %105, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %cc, %Qubit* %qb__46) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) call void @__quantum__rt__qubit_release_array(%Array* %cc) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %cc, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) call void @__quantum__rt__qubit_release_array(%Array* %qs) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qs, i64 -1) ret void } @@ -1337,25 +1352,25 @@ declare void @__quantum__rt__qubit_release_array(%Array*) define void @Microsoft__Quantum__Testing__Tracer__TestMeasurements__body() { entry: %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 6) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %1 = bitcast i8* %0 to %Qubit** - %qb = load %Qubit*, %Qubit** %1 + %qb = load %Qubit*, %Qubit** %1, align 8 call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) %2 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %3 = bitcast i8* %2 to %Qubit** - %qb__2 = load %Qubit*, %Qubit** %3 + %qb__2 = load %Qubit*, %Qubit** %3, align 8 %r0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__2) %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %5 = bitcast i8* %4 to %Qubit** - %qb__4 = load %Qubit*, %Qubit** %5 + %qb__4 = load %Qubit*, %Qubit** %5, align 8 call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__4) %6 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %7 = bitcast i8* %6 to %Qubit** - %8 = load %Qubit*, %Qubit** %7 + %8 = load %Qubit*, %Qubit** %7, align 8 %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %10 = bitcast i8* %9 to %Qubit** - %11 = load %Qubit*, %Qubit** %10 + %11 = load %Qubit*, %Qubit** %10, align 8 call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %8, %Qubit* %11) %qs12 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 2) %12 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) @@ -1364,30 +1379,30 @@ entry: %15 = bitcast i8* %14 to %Qubit** %16 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %17 = bitcast i8* %16 to %Qubit** - %18 = load %Qubit*, %Qubit** %17 + %18 = load %Qubit*, %Qubit** %17, align 8 %19 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %20 = bitcast i8* %19 to %Qubit** - %21 = load %Qubit*, %Qubit** %20 - store %Qubit* %18, %Qubit** %13 - store %Qubit* %21, %Qubit** %15 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) + %21 = load %Qubit*, %Qubit** %20, align 8 + store %Qubit* %18, %Qubit** %13, align 8 + store %Qubit* %21, %Qubit** %15, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) %paulis = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %23 = bitcast i8* %22 to i2* %24 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %25 = bitcast i8* %24 to i2* - %26 = load i2, i2* @PauliY - %27 = load i2, i2* @PauliX - store i2 %26, i2* %23 - store i2 %27, i2* %25 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) - %28 = load %Result*, %Result** @ResultOne - %res = alloca %Result* - store %Result* %28, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %28, i64 1) - %haveY = alloca i1 - store i1 false, i1* %haveY + %26 = load i2, i2* @PauliY, align 1 + %27 = load i2, i2* @PauliX, align 1 + store i2 %26, i2* %23, align 1 + store i2 %27, i2* %25, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) + %28 = call %Result* @__quantum__rt__result_get_one() + %res = alloca %Result*, align 8 + store %Result* %28, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %28, i32 1) + %haveY = alloca i1, align 1 + store i1 false, i1* %haveY, align 1 br label %header__1 header__1: ; preds = %exiting__1, %entry @@ -1398,22 +1413,28 @@ header__1: ; preds = %exiting__1, %entry body__1: ; preds = %header__1 %30 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) %31 = bitcast i8* %30 to i2* - %32 = load i2, i2* %31 - %33 = load i2, i2* @PauliY + %32 = load i2, i2* %31, align 1 + %33 = load i2, i2* @PauliY, align 1 %34 = icmp eq i2 %32, %33 + br i1 %34, label %condContinue__1, label %condFalse__1 + +condFalse__1: ; preds = %body__1 %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) %36 = bitcast i8* %35 to i2* - %37 = load i2, i2* %36 - %38 = load i2, i2* @PauliI + %37 = load i2, i2* %36, align 1 + %38 = load i2, i2* @PauliI, align 1 %39 = icmp eq i2 %37, %38 - %40 = or i1 %34, %39 + br label %condContinue__1 + +condContinue__1: ; preds = %condFalse__1, %body__1 + %40 = phi i1 [ %34, %body__1 ], [ %39, %condFalse__1 ] br i1 %40, label %then0__1, label %continue__1 -then0__1: ; preds = %body__1 - store i1 true, i1* %haveY +then0__1: ; preds = %condContinue__1 + store i1 true, i1* %haveY, align 1 br label %continue__1 -continue__1: ; preds = %then0__1, %body__1 +continue__1: ; preds = %then0__1, %condContinue__1 br label %exiting__1 exiting__1: ; preds = %continue__1 @@ -1421,15 +1442,15 @@ exiting__1: ; preds = %continue__1 br label %header__1 exit__1: ; preds = %header__1 - %42 = load i1, i1* %haveY + %42 = load i1, i1* %haveY, align 1 br i1 %42, label %then0__2, label %test1__1 then0__2: ; preds = %exit__1 %43 = call %Result* @__quantum__qis__joint_measure(i64 106, i64 1, %Array* %qs12) - call void @__quantum__rt__result_update_reference_count(%Result* %43, i64 1) - store %Result* %43, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %43, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %28, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %43, i32 1) + store %Result* %43, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %43, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %28, i32 -1) br label %continue__2 test1__1: ; preds = %exit__1 @@ -1437,11 +1458,11 @@ test1__1: ; preds = %exit__1 then1__1: ; preds = %test1__1 %44 = call %Result* @__quantum__qis__joint_measure(i64 107, i64 1, %Array* %qs12) - call void @__quantum__rt__result_update_reference_count(%Result* %44, i64 1) - %45 = load %Result*, %Result** %res - store %Result* %44, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %44, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %45, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %44, i32 1) + %45 = load %Result*, %Result** %res, align 8 + store %Result* %44, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %44, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %45, i32 -1) br label %continue__2 test2__1: ; preds = %test1__1 @@ -1450,33 +1471,33 @@ test2__1: ; preds = %test1__1 then2__1: ; preds = %test2__1 %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %47 = bitcast i8* %46 to i2* - %48 = load i2, i2* %47 - %49 = load i2, i2* @PauliX + %48 = load i2, i2* %47, align 1 + %49 = load i2, i2* @PauliX, align 1 %50 = icmp eq i2 %48, %49 br i1 %50, label %then0__3, label %else__1 then0__3: ; preds = %then2__1 %51 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) %52 = bitcast i8* %51 to %Qubit** - %qb__6 = load %Qubit*, %Qubit** %52 + %qb__6 = load %Qubit*, %Qubit** %52, align 8 %53 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb__6) - call void @__quantum__rt__result_update_reference_count(%Result* %53, i64 1) - %54 = load %Result*, %Result** %res - store %Result* %53, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %53, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %54, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %53, i32 1) + %54 = load %Result*, %Result** %res, align 8 + store %Result* %53, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %53, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %54, i32 -1) br label %continue__3 else__1: ; preds = %then2__1 %55 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) %56 = bitcast i8* %55 to %Qubit** - %qb__7 = load %Qubit*, %Qubit** %56 + %qb__7 = load %Qubit*, %Qubit** %56, align 8 %57 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__7) - call void @__quantum__rt__result_update_reference_count(%Result* %57, i64 1) - %58 = load %Result*, %Result** %res - store %Result* %57, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %57, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %58, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %57, i32 1) + %58 = load %Result*, %Result** %res, align 8 + store %Result* %57, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %57, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %58, i32 -1) br label %continue__3 continue__3: ; preds = %else__1, %then0__3 @@ -1485,185 +1506,208 @@ continue__3: ; preds = %else__1, %then0__3 test3__1: ; preds = %test2__1 %59 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %60 = bitcast i8* %59 to i2* - %61 = load i2, i2* %60 - %62 = load i2, i2* @PauliX + %61 = load i2, i2* %60, align 1 + %62 = load i2, i2* @PauliX, align 1 %63 = icmp eq i2 %61, %62 + br i1 %63, label %condTrue__1, label %condContinue__2 + +condTrue__1: ; preds = %test3__1 %64 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %65 = bitcast i8* %64 to i2* - %66 = load i2, i2* %65 - %67 = load i2, i2* @PauliX + %66 = load i2, i2* %65, align 1 + %67 = load i2, i2* @PauliX, align 1 %68 = icmp eq i2 %66, %67 - %69 = and i1 %63, %68 + br label %condContinue__2 + +condContinue__2: ; preds = %condTrue__1, %test3__1 + %69 = phi i1 [ %68, %condTrue__1 ], [ %63, %test3__1 ] br i1 %69, label %then3__1, label %test4__1 -then3__1: ; preds = %test3__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) +then3__1: ; preds = %condContinue__2 + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) %70 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %70, i64 1) - %71 = load %Result*, %Result** %res - store %Result* %70, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %70, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %71, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %70, i32 1) + %71 = load %Result*, %Result** %res, align 8 + store %Result* %70, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %70, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %71, i32 -1) br label %continue__2 -test4__1: ; preds = %test3__1 +test4__1: ; preds = %condContinue__2 %72 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %73 = bitcast i8* %72 to i2* - %74 = load i2, i2* %73 - %75 = load i2, i2* @PauliX + %74 = load i2, i2* %73, align 1 + %75 = load i2, i2* @PauliX, align 1 %76 = icmp eq i2 %74, %75 + br i1 %76, label %condTrue__2, label %condContinue__3 + +condTrue__2: ; preds = %test4__1 %77 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %78 = bitcast i8* %77 to i2* - %79 = load i2, i2* %78 - %80 = load i2, i2* @PauliZ + %79 = load i2, i2* %78, align 1 + %80 = load i2, i2* @PauliZ, align 1 %81 = icmp eq i2 %79, %80 - %82 = and i1 %76, %81 + br label %condContinue__3 + +condContinue__3: ; preds = %condTrue__2, %test4__1 + %82 = phi i1 [ %81, %condTrue__2 ], [ %76, %test4__1 ] br i1 %82, label %then4__1, label %test5__1 -then4__1: ; preds = %test4__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) +then4__1: ; preds = %condContinue__3 + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) %83 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %83, i64 1) - %84 = load %Result*, %Result** %res - store %Result* %83, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %83, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %84, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %83, i32 1) + %84 = load %Result*, %Result** %res, align 8 + store %Result* %83, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %83, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %84, i32 -1) br label %continue__2 -test5__1: ; preds = %test4__1 +test5__1: ; preds = %condContinue__3 %85 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %86 = bitcast i8* %85 to i2* - %87 = load i2, i2* %86 - %88 = load i2, i2* @PauliZ + %87 = load i2, i2* %86, align 1 + %88 = load i2, i2* @PauliZ, align 1 %89 = icmp eq i2 %87, %88 + br i1 %89, label %condTrue__3, label %condContinue__4 + +condTrue__3: ; preds = %test5__1 %90 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %91 = bitcast i8* %90 to i2* - %92 = load i2, i2* %91 - %93 = load i2, i2* @PauliX + %92 = load i2, i2* %91, align 1 + %93 = load i2, i2* @PauliX, align 1 %94 = icmp eq i2 %92, %93 - %95 = and i1 %89, %94 + br label %condContinue__4 + +condContinue__4: ; preds = %condTrue__3, %test5__1 + %95 = phi i1 [ %94, %condTrue__3 ], [ %89, %test5__1 ] br i1 %95, label %then5__1, label %test6__1 -then5__1: ; preds = %test5__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) +then5__1: ; preds = %condContinue__4 + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) %96 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %96, i64 1) - %97 = load %Result*, %Result** %res - store %Result* %96, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %96, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %97, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %96, i32 1) + %97 = load %Result*, %Result** %res, align 8 + store %Result* %96, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %96, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %97, i32 -1) br label %continue__2 -test6__1: ; preds = %test5__1 +test6__1: ; preds = %condContinue__4 %98 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %99 = bitcast i8* %98 to i2* - %100 = load i2, i2* %99 - %101 = load i2, i2* @PauliZ + %100 = load i2, i2* %99, align 1 + %101 = load i2, i2* @PauliZ, align 1 %102 = icmp eq i2 %100, %101 + br i1 %102, label %condTrue__4, label %condContinue__5 + +condTrue__4: ; preds = %test6__1 %103 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %104 = bitcast i8* %103 to i2* - %105 = load i2, i2* %104 - %106 = load i2, i2* @PauliZ + %105 = load i2, i2* %104, align 1 + %106 = load i2, i2* @PauliZ, align 1 %107 = icmp eq i2 %105, %106 - %108 = and i1 %102, %107 + br label %condContinue__5 + +condContinue__5: ; preds = %condTrue__4, %test6__1 + %108 = phi i1 [ %107, %condTrue__4 ], [ %102, %test6__1 ] br i1 %108, label %then6__1, label %continue__2 -then6__1: ; preds = %test6__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) +then6__1: ; preds = %condContinue__5 + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) %109 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %109, i64 1) - %110 = load %Result*, %Result** %res - store %Result* %109, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %109, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %110, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %109, i32 1) + %110 = load %Result*, %Result** %res, align 8 + store %Result* %109, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %109, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %110, i32 -1) br label %continue__2 -continue__2: ; preds = %then6__1, %test6__1, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 - %r12 = load %Result*, %Result** %res - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis, i64 -1) +continue__2: ; preds = %then6__1, %condContinue__5, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 + %r12 = load %Result*, %Result** %res, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %paulis, i32 -1) %111 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %112 = bitcast %Tuple* %111 to { %Callable*, %Callable*, %Qubit* }* %113 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 0 %114 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 1 %115 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 2 - %116 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) - %117 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__X, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %116 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %117 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__X, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %118 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 3) %119 = bitcast i8* %118 to %Qubit** - %120 = load %Qubit*, %Qubit** %119 - store %Callable* %116, %Callable** %113 - store %Callable* %117, %Callable** %114 - store %Qubit* %120, %Qubit** %115 - %121 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__1, [2 x void (%Tuple*, i64)*]* @MemoryManagement__1, %Tuple* %111) + %120 = load %Qubit*, %Qubit** %119, align 8 + store %Callable* %116, %Callable** %113, align 8 + store %Callable* %117, %Callable** %114, align 8 + store %Qubit* %120, %Qubit** %115, align 8 + %121 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__1, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %111) %122 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %123 = bitcast %Tuple* %122 to { %Callable*, %Callable*, %Qubit* }* %124 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 0 %125 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 1 %126 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 2 - %127 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) - %128 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Y, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %127 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %128 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Y, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %129 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 3) %130 = bitcast i8* %129 to %Qubit** - %131 = load %Qubit*, %Qubit** %130 - store %Callable* %127, %Callable** %124 - store %Callable* %128, %Callable** %125 - store %Qubit* %131, %Qubit** %126 - %132 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__2, [2 x void (%Tuple*, i64)*]* @MemoryManagement__1, %Tuple* %122) + %131 = load %Qubit*, %Qubit** %130, align 8 + store %Callable* %127, %Callable** %124, align 8 + store %Callable* %128, %Callable** %125, align 8 + store %Qubit* %131, %Qubit** %126, align 8 + %132 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__2, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %122) call void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %r0, %Callable* %121, %Callable* %132) %133 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %134 = bitcast %Tuple* %133 to { %Callable*, %Callable*, %Qubit* }* %135 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 0 %136 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 1 %137 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 2 - %138 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) - %139 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Z, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %138 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %139 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Z, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %140 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 4) %141 = bitcast i8* %140 to %Qubit** - %142 = load %Qubit*, %Qubit** %141 - store %Callable* %138, %Callable** %135 - store %Callable* %139, %Callable** %136 - store %Qubit* %142, %Qubit** %137 - %143 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__3, [2 x void (%Tuple*, i64)*]* @MemoryManagement__1, %Tuple* %133) + %142 = load %Qubit*, %Qubit** %141, align 8 + store %Callable* %138, %Callable** %135, align 8 + store %Callable* %139, %Callable** %136, align 8 + store %Qubit* %142, %Qubit** %137, align 8 + %143 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__3, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %133) %144 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %145 = bitcast %Tuple* %144 to { %Callable*, %Callable*, %Qubit* }* %146 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 0 %147 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 1 %148 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 2 - %149 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) - %150 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__S, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %149 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %150 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__S, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %151 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 4) %152 = bitcast i8* %151 to %Qubit** - %153 = load %Qubit*, %Qubit** %152 - store %Callable* %149, %Callable** %146 - store %Callable* %150, %Callable** %147 - store %Qubit* %153, %Qubit** %148 - %154 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__4, [2 x void (%Tuple*, i64)*]* @MemoryManagement__2, %Tuple* %144) + %153 = load %Qubit*, %Qubit** %152, align 8 + store %Callable* %149, %Callable** %146, align 8 + store %Callable* %150, %Callable** %147, align 8 + store %Qubit* %153, %Qubit** %148, align 8 + %154 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__4, [2 x void (%Tuple*, i32)*]* @MemoryManagement__2, %Tuple* %144) call void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %r12, %Callable* %143, %Callable* %154) %155 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 5) %156 = bitcast i8* %155 to %Qubit** - %qb__8 = load %Qubit*, %Qubit** %156 + %qb__8 = load %Qubit*, %Qubit** %156, align 8 call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__8) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %r0, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %r12, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %121, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %121, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %132, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %132, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %143, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %143, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %154, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %154, i32 -1) call void @__quantum__rt__qubit_release_array(%Array* %qs) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qs, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %r0, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %r12, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %121, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %121, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %132, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %132, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %143, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %143, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %154, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %154, i64 -1) ret void } @@ -1673,20 +1717,20 @@ entry: %1 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 1 %3 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 2 - %4 = load %Callable*, %Callable** %1 - %5 = load %Qubit*, %Qubit** %2 - %6 = load %Tuple*, %Tuple** %3 + %4 = load %Callable*, %Callable** %1, align 8 + %5 = load %Qubit*, %Qubit** %2, align 8 + %6 = load %Tuple*, %Tuple** %3, align 8 call void @Microsoft__Quantum__Testing__Tracer__Delay__body(%Callable* %4, %Qubit* %5, %Tuple* %6) ret void } -declare %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]*, [2 x void (%Tuple*, i64)*]*, %Tuple*) +declare %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]*, [2 x void (%Tuple*, i32)*]*, %Tuple*) define void @Microsoft__Quantum__Intrinsic__X__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %2) ret void } @@ -1695,7 +1739,7 @@ define void @Microsoft__Quantum__Intrinsic__X__adj__wrapper(%Tuple* %capture-tup entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %2) ret void } @@ -1705,8 +1749,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1716,8 +1760,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1726,54 +1770,54 @@ define void @Lifted__PartialApplication__1__body__wrapper(%Tuple* %capture-tuple entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1 + %2 = load %Callable*, %Callable** %1, align 8 %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3 + %4 = load %Qubit*, %Qubit** %3, align 8 %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6 + %7 = load %Tuple*, %Tuple** %6, align 8 %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10 - store %Qubit* %4, %Qubit** %11 - store %Tuple* %7, %Tuple** %12 + store %Callable* %2, %Callable** %10, align 8 + store %Qubit* %4, %Qubit** %11, align 8 + store %Tuple* %7, %Tuple** %12, align 8 %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13 + %14 = load %Callable*, %Callable** %13, align 8 call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) ret void } -define void @MemoryManagement__1__RefCount(%Tuple* %capture-tuple, i64 %count-change) { +define void @MemoryManagement__1__RefCount(%Tuple* %capture-tuple, i32 %count-change) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %2, i64 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i64 %count-change) + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %4, i64 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i64 %count-change) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i64 %count-change) + %4 = load %Callable*, %Callable** %3, align 8 + call void @__quantum__rt__capture_update_reference_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) ret void } -define void @MemoryManagement__1__AliasCount(%Tuple* %capture-tuple, i64 %count-change) { +define void @MemoryManagement__1__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1 - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %2, i64 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i64 %count-change) + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3 - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %4, i64 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i64 %count-change) - call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i64 %count-change) + %4 = load %Callable*, %Callable** %3, align 8 + call void @__quantum__rt__capture_update_alias_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) ret void } @@ -1781,7 +1825,7 @@ define void @Microsoft__Quantum__Intrinsic__Y__body__wrapper(%Tuple* %capture-tu entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %2) ret void } @@ -1790,7 +1834,7 @@ define void @Microsoft__Quantum__Intrinsic__Y__adj__wrapper(%Tuple* %capture-tup entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %2) ret void } @@ -1800,8 +1844,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1811,8 +1855,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1821,24 +1865,24 @@ define void @Lifted__PartialApplication__2__body__wrapper(%Tuple* %capture-tuple entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1 + %2 = load %Callable*, %Callable** %1, align 8 %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3 + %4 = load %Qubit*, %Qubit** %3, align 8 %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6 + %7 = load %Tuple*, %Tuple** %6, align 8 %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10 - store %Qubit* %4, %Qubit** %11 - store %Tuple* %7, %Tuple** %12 + store %Callable* %2, %Callable** %10, align 8 + store %Qubit* %4, %Qubit** %11, align 8 + store %Tuple* %7, %Tuple** %12, align 8 %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13 + %14 = load %Callable*, %Callable** %13, align 8 call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) ret void } @@ -1846,7 +1890,7 @@ define void @Microsoft__Quantum__Intrinsic__Z__body__wrapper(%Tuple* %capture-tu entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %2) ret void } @@ -1855,7 +1899,7 @@ define void @Microsoft__Quantum__Intrinsic__Z__adj__wrapper(%Tuple* %capture-tup entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %2) ret void } @@ -1865,8 +1909,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1876,8 +1920,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1886,24 +1930,24 @@ define void @Lifted__PartialApplication__3__body__wrapper(%Tuple* %capture-tuple entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1 + %2 = load %Callable*, %Callable** %1, align 8 %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3 + %4 = load %Qubit*, %Qubit** %3, align 8 %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6 + %7 = load %Tuple*, %Tuple** %6, align 8 %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10 - store %Qubit* %4, %Qubit** %11 - store %Tuple* %7, %Tuple** %12 + store %Callable* %2, %Callable** %10, align 8 + store %Qubit* %4, %Qubit** %11, align 8 + store %Tuple* %7, %Tuple** %12, align 8 %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13 + %14 = load %Callable*, %Callable** %13, align 8 call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) ret void } @@ -1911,7 +1955,7 @@ define void @Microsoft__Quantum__Intrinsic__S__body__wrapper(%Tuple* %capture-tu entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %2) ret void } @@ -1920,7 +1964,7 @@ define void @Microsoft__Quantum__Intrinsic__S__adj__wrapper(%Tuple* %capture-tup entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %2) ret void } @@ -1930,8 +1974,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1941,8 +1985,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1951,69 +1995,86 @@ define void @Lifted__PartialApplication__4__body__wrapper(%Tuple* %capture-tuple entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1 + %2 = load %Callable*, %Callable** %1, align 8 %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3 + %4 = load %Qubit*, %Qubit** %3, align 8 %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6 + %7 = load %Tuple*, %Tuple** %6, align 8 %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10 - store %Qubit* %4, %Qubit** %11 - store %Tuple* %7, %Tuple** %12 + store %Callable* %2, %Callable** %10, align 8 + store %Qubit* %4, %Qubit** %11, align 8 + store %Tuple* %7, %Tuple** %12, align 8 %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13 + %14 = load %Callable*, %Callable** %13, align 8 call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) ret void } -define void @MemoryManagement__2__RefCount(%Tuple* %capture-tuple, i64 %count-change) { +define void @MemoryManagement__2__RefCount(%Tuple* %capture-tuple, i32 %count-change) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %2, i64 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i64 %count-change) + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %4, i64 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i64 %count-change) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i64 %count-change) + %4 = load %Callable*, %Callable** %3, align 8 + call void @__quantum__rt__capture_update_reference_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) ret void } -define void @MemoryManagement__2__AliasCount(%Tuple* %capture-tuple, i64 %count-change) { +define void @MemoryManagement__2__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1 - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %2, i64 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i64 %count-change) + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3 - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %4, i64 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i64 %count-change) - call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i64 %count-change) + %4 = load %Callable*, %Callable** %3, align 8 + call void @__quantum__rt__capture_update_alias_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) ret void } -declare void @__quantum__rt__callable_update_reference_count(%Callable*, i64) +declare void @__quantum__rt__capture_update_reference_count(%Callable*, i32) + +declare void @__quantum__rt__callable_update_reference_count(%Callable*, i32) + +define %Tuple* @Microsoft__Quantum__Core__Attribute__body() { +entry: + ret %Tuple* null +} + +define %Tuple* @Microsoft__Quantum__Core__EntryPoint__body() { +entry: + ret %Tuple* null +} + +define %Tuple* @Microsoft__Quantum__Core__Inline__body() { +entry: + ret %Tuple* null +} define { %String* }* @Microsoft__Quantum__Targeting__TargetInstruction__body(%String* %__Item1__) { entry: %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) %1 = bitcast %Tuple* %0 to { %String* }* %2 = getelementptr inbounds { %String* }, { %String* }* %1, i32 0, i32 0 - store %String* %__Item1__, %String** %2 - call void @__quantum__rt__string_update_reference_count(%String* %__Item1__, i64 1) + store %String* %__Item1__, %String** %2, align 8 + call void @__quantum__rt__string_update_reference_count(%String* %__Item1__, i32 1) ret { %String* }* %1 } -declare void @__quantum__rt__string_update_reference_count(%String*, i64) +declare void @__quantum__rt__string_update_reference_count(%String*, i32) -declare void @__quantum__rt__tuple_update_alias_count(%Tuple*, i64) +declare void @__quantum__rt__tuple_update_alias_count(%Tuple*, i32) diff --git a/src/QirRuntime/test/QIR-tracer/tracer-conditionals.qs b/src/QirRuntime/test/QIR-tracer/qsharp/tracer-conditionals.qs similarity index 97% rename from src/QirRuntime/test/QIR-tracer/tracer-conditionals.qs rename to src/QirRuntime/test/QIR-tracer/qsharp/tracer-conditionals.qs index e9c0c512421..718808a2a3b 100644 --- a/src/QirRuntime/test/QIR-tracer/tracer-conditionals.qs +++ b/src/QirRuntime/test/QIR-tracer/qsharp/tracer-conditionals.qs @@ -1,25 +1,25 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -namespace Microsoft.Quantum.Testing.Tracer { - open Microsoft.Quantum.Intrinsic; - - // Private helper operations. - operation Delay(op : (Qubit => Unit), arg : Qubit, aux : Unit) : Unit { - op(arg); - } - - operation TestMeasurements() : Unit { - use qs = Qubit[6]; - T(qs[0]); // layer 0 - let r0 = M(qs[0]); // layer 1 - T(qs[1]); // layer 0 - CNOT(qs[1], qs[2]); // layer 1 - let qs12 = [qs[1], qs[2]]; - let r12 = Measure([PauliY, PauliX], qs12); // layer 2 - - ApplyIfElseIntrinsic(r0, Delay(X, qs[3], _), Delay(Y, qs[3], _)); // layers 2, 3 - ApplyIfElseIntrinsic(r12, Delay(Z, qs[4], _), Delay(S, qs[4], _)); // layer 3, 4 - Rx(4.2, qs[5]); // layer 0 - } +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +namespace Microsoft.Quantum.Testing.Tracer { + open Microsoft.Quantum.Intrinsic; + + // Private helper operations. + operation Delay(op : (Qubit => Unit), arg : Qubit, aux : Unit) : Unit { + op(arg); + } + + operation TestMeasurements() : Unit { + use qs = Qubit[6]; + T(qs[0]); // layer 0 + let r0 = M(qs[0]); // layer 1 + T(qs[1]); // layer 0 + CNOT(qs[1], qs[2]); // layer 1 + let qs12 = [qs[1], qs[2]]; + let r12 = Measure([PauliY, PauliX], qs12); // layer 2 + + ApplyIfElseIntrinsic(r0, Delay(X, qs[3], _), Delay(Y, qs[3], _)); // layers 2, 3 + ApplyIfElseIntrinsic(r12, Delay(Z, qs[4], _), Delay(S, qs[4], _)); // layer 3, 4 + Rx(4.2, qs[5]); // layer 0 + } } \ No newline at end of file diff --git a/src/QirRuntime/test/QIR-tracer/tracer-core.qs b/src/QirRuntime/test/QIR-tracer/qsharp/tracer-core.qs similarity index 100% rename from src/QirRuntime/test/QIR-tracer/tracer-core.qs rename to src/QirRuntime/test/QIR-tracer/qsharp/tracer-core.qs diff --git a/src/QirRuntime/test/QIR-tracer/tracer-intrinsics.qs b/src/QirRuntime/test/QIR-tracer/qsharp/tracer-intrinsics.qs similarity index 100% rename from src/QirRuntime/test/QIR-tracer/tracer-intrinsics.qs rename to src/QirRuntime/test/QIR-tracer/qsharp/tracer-intrinsics.qs diff --git a/src/QirRuntime/test/QIR-tracer/qsharp/tracer-qir.csproj b/src/QirRuntime/test/QIR-tracer/qsharp/tracer-qir.csproj new file mode 100644 index 00000000000..0167e216edf --- /dev/null +++ b/src/QirRuntime/test/QIR-tracer/qsharp/tracer-qir.csproj @@ -0,0 +1,10 @@ + + + + Exe + netcoreapp3.1 + True + false + + + diff --git a/src/QirRuntime/test/QIR-tracer/tracer-target.qs b/src/QirRuntime/test/QIR-tracer/qsharp/tracer-target.qs similarity index 100% rename from src/QirRuntime/test/QIR-tracer/tracer-target.qs rename to src/QirRuntime/test/QIR-tracer/qsharp/tracer-target.qs diff --git a/src/QirRuntime/test/QIR-tracer/tracer-qir-lnx.ll b/src/QirRuntime/test/QIR-tracer/tracer-qir.ll similarity index 78% rename from src/QirRuntime/test/QIR-tracer/tracer-qir-lnx.ll rename to src/QirRuntime/test/QIR-tracer/tracer-qir.ll index ab33750832b..0bf147d470f 100644 --- a/src/QirRuntime/test/QIR-tracer/tracer-qir-lnx.ll +++ b/src/QirRuntime/test/QIR-tracer/tracer-qir.ll @@ -1,14 +1,12 @@ -%Result = type opaque %Range = type { i64, i64, i64 } %Tuple = type opaque +%Result = type opaque +%Qubit = type opaque %Array = type opaque %Callable = type opaque -%Qubit = type opaque %String = type opaque -@ResultZero = external global %Result* -@ResultOne = external global %Result* @PauliI = constant i2 0 @PauliX = constant i2 1 @PauliY = constant i2 -1 @@ -17,63 +15,227 @@ @Microsoft__Quantum__Testing__Tracer__Delay = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Testing__Tracer__Delay__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] @Microsoft__Quantum__Intrinsic__X = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper] @PartialApplication__1 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@MemoryManagement__1 = constant [2 x void (%Tuple*, i64)*] [void (%Tuple*, i64)* @MemoryManagement__1__RefCount, void (%Tuple*, i64)* @MemoryManagement__1__AliasCount] +@MemoryManagement__1 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__1__RefCount, void (%Tuple*, i32)* @MemoryManagement__1__AliasCount] @Microsoft__Quantum__Intrinsic__Y = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper] @PartialApplication__2 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__2__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] @Microsoft__Quantum__Intrinsic__Z = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper] @PartialApplication__3 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__3__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] @Microsoft__Quantum__Intrinsic__S = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper] @PartialApplication__4 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__4__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@MemoryManagement__2 = constant [2 x void (%Tuple*, i64)*] [void (%Tuple*, i64)* @MemoryManagement__2__RefCount, void (%Tuple*, i64)* @MemoryManagement__2__AliasCount] +@MemoryManagement__2 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__2__RefCount, void (%Tuple*, i32)* @MemoryManagement__2__AliasCount] + +define %Result* @Microsoft__Quantum__Instructions__Mx__body(%Qubit* %qb) { +entry: + %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb) + ret %Result* %0 +} + +declare %Result* @__quantum__qis__single_qubit_measure(i64, i64, %Qubit*) + +define %Result* @Microsoft__Quantum__Instructions__Mxx__body(%Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +declare void @__quantum__rt__array_update_alias_count(%Array*, i32) + +declare %Result* @__quantum__qis__joint_measure(i64, i64, %Array*) + +define %Result* @Microsoft__Quantum__Instructions__Mxz__body(%Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +define %Result* @Microsoft__Quantum__Instructions__Mz__body(%Qubit* %qb) { +entry: + %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb) + ret %Result* %0 +} + +define %Result* @Microsoft__Quantum__Instructions__Mzx__body(%Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +define %Result* @Microsoft__Quantum__Instructions__Mzz__body(%Array* %qubits) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qubits) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + ret %Result* %0 +} + +define void @Microsoft__Quantum__Instructions__Sx__body(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) + ret void +} + +declare void @__quantum__qis__single_qubit_op(i64, i64, %Qubit*) + +define void @Microsoft__Quantum__Instructions__Sx__adj(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Sx__ctl(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +declare void @__quantum__qis__single_qubit_op_ctl(i64, i64, %Array*, %Qubit*) + +define void @Microsoft__Quantum__Instructions__Sx__ctladj(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Sz__body(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Sz__adj(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Sz__ctl(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Sz__ctladj(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tx__body(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tx__adj(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tx__ctl(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tx__ctladj(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tz__body(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tz__adj(%Qubit* %qb) { +entry: + call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tz__ctl(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} + +define void @Microsoft__Quantum__Instructions__Tz__ctladj(%Array* %ctls, %Qubit* %qb) { +entry: + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + ret void +} define void @Microsoft__Quantum__Intrinsic__ApplyConditionallyIntrinsic__body(%Array* %measurementResults, %Array* %resultsValues, %Callable* %onEqualOp, %Callable* %onNonEqualOp) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i64 1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onEqualOp, i64 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i64 1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onNonEqualOp, i64 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i32 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onEqualOp, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i32 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onNonEqualOp, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i32 1) call void @__quantum__qis__apply_conditionally(%Array* %measurementResults, %Array* %resultsValues, %Callable* %onEqualOp, %Callable* %onNonEqualOp) - call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onEqualOp, i64 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onNonEqualOp, i64 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i32 -1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onEqualOp, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i32 -1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onNonEqualOp, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i32 -1) ret void } -declare void @__quantum__rt__array_update_alias_count(%Array*, i64) - -declare void @__quantum__rt__callable_memory_management(i32, %Callable*, i64) +declare void @__quantum__rt__capture_update_alias_count(%Callable*, i32) -declare void @__quantum__rt__callable_update_alias_count(%Callable*, i64) +declare void @__quantum__rt__callable_update_alias_count(%Callable*, i32) declare void @__quantum__qis__apply_conditionally(%Array*, %Array*, %Callable*, %Callable*) define void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %measurementResult, %Callable* %onResultZeroOp, %Callable* %onResultOneOp) { entry: - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onResultZeroOp, i64 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i64 1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onResultOneOp, i64 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i64 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultZeroOp, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i32 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultOneOp, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i32 1) %0 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %1 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %0, i64 0) %2 = bitcast i8* %1 to %Result** - store %Result* %measurementResult, %Result** %2 + store %Result* %measurementResult, %Result** %2, align 8 %3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 0) %5 = bitcast i8* %4 to %Result** - %6 = load %Result*, %Result** @ResultZero - store %Result* %6, %Result** %5 + %6 = call %Result* @__quantum__rt__result_get_zero() + store %Result* %6, %Result** %5, align 8 call void @__quantum__qis__apply_conditionally(%Array* %0, %Array* %3, %Callable* %onResultZeroOp, %Callable* %onResultOneOp) - call void @__quantum__rt__result_update_reference_count(%Result* %measurementResult, i64 1) - call void @__quantum__rt__result_update_reference_count(%Result* %6, i64 1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onResultZeroOp, i64 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %onResultOneOp, i64 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %measurementResult, i32 1) + call void @__quantum__rt__result_update_reference_count(%Result* %6, i32 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultZeroOp, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i32 -1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultOneOp, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i32 -1) br label %header__1 header__1: ; preds = %exiting__1, %entry @@ -84,8 +246,8 @@ header__1: ; preds = %exiting__1, %entry body__1: ; preds = %header__1 %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %0, i64 %7) %10 = bitcast i8* %9 to %Result** - %11 = load %Result*, %Result** %10 - call void @__quantum__rt__result_update_reference_count(%Result* %11, i64 -1) + %11 = load %Result*, %Result** %10, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %11, i32 -1) br label %exiting__1 exiting__1: ; preds = %body__1 @@ -93,7 +255,7 @@ exiting__1: ; preds = %body__1 br label %header__1 exit__1: ; preds = %header__1 - call void @__quantum__rt__array_update_reference_count(%Array* %0, i64 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %0, i32 -1) br label %header__2 header__2: ; preds = %exiting__2, %exit__1 @@ -104,8 +266,8 @@ header__2: ; preds = %exiting__2, %exit__ body__2: ; preds = %header__2 %15 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 %13) %16 = bitcast i8* %15 to %Result** - %17 = load %Result*, %Result** %16 - call void @__quantum__rt__result_update_reference_count(%Result* %17, i64 -1) + %17 = load %Result*, %Result** %16, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 -1) br label %exiting__2 exiting__2: ; preds = %body__2 @@ -113,7 +275,7 @@ exiting__2: ; preds = %body__2 br label %header__2 exit__2: ; preds = %header__2 - call void @__quantum__rt__array_update_reference_count(%Array* %3, i64 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %3, i32 -1) ret void } @@ -121,17 +283,19 @@ declare %Array* @__quantum__rt__array_create_1d(i32, i64) declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) -declare void @__quantum__rt__result_update_reference_count(%Result*, i64) +declare %Result* @__quantum__rt__result_get_zero() -declare void @__quantum__rt__array_update_reference_count(%Array*, i64) +declare void @__quantum__rt__result_update_reference_count(%Result*, i32) + +declare void @__quantum__rt__array_update_reference_count(%Array*, i32) define void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %control, %Qubit* %target) { entry: %ctls = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) %1 = bitcast i8* %0 to %Qubit** - store %Qubit* %control, %Qubit** %1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + store %Qubit* %control, %Qubit** %1, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) br i1 true, label %then0__1, label %else__1 then0__1: ; preds = %entry @@ -143,13 +307,11 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i32 -1) ret void } -declare void @__quantum__qis__single_qubit_op_ctl(i64, i64, %Array*, %Qubit*) - define void @Microsoft__Quantum__Intrinsic__CNOT__adj(%Qubit* %control, %Qubit* %target) { entry: call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %control, %Qubit* %target) @@ -158,17 +320,17 @@ entry: define void @Microsoft__Quantum__Intrinsic__CNOT__ctl(%Array* %ctls, { %Qubit*, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 0 - %control = load %Qubit*, %Qubit** %1 + %control = load %Qubit*, %Qubit** %1, align 8 %2 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 1 - %target = load %Qubit*, %Qubit** %2 + %target = load %Qubit*, %Qubit** %2, align 8 %3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 0) %5 = bitcast i8* %4 to %Qubit** - store %Qubit* %control, %Qubit** %5 + store %Qubit* %control, %Qubit** %5, align 8 %ctls__1 = call %Array* @__quantum__rt__array_concatenate(%Array* %ctls, %Array* %3) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 1) %6 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls__1) %7 = icmp eq i64 %6, 1 br i1 %7, label %then0__1, label %else__1 @@ -182,10 +344,10 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %3, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %3, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -195,26 +357,26 @@ declare i64 @__quantum__rt__array_get_size_1d(%Array*) define void @Microsoft__Quantum__Intrinsic__CNOT__ctladj(%Array* %__controlQubits__, { %Qubit*, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) %1 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 0 - %control = load %Qubit*, %Qubit** %1 + %control = load %Qubit*, %Qubit** %1, align 8 %2 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 1 - %target = load %Qubit*, %Qubit** %2 + %target = load %Qubit*, %Qubit** %2, align 8 %3 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) %4 = bitcast %Tuple* %3 to { %Qubit*, %Qubit* }* %5 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %4, i32 0, i32 0 %6 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %4, i32 0, i32 1 - store %Qubit* %control, %Qubit** %5 - store %Qubit* %target, %Qubit** %6 + store %Qubit* %control, %Qubit** %5, align 8 + store %Qubit* %target, %Qubit** %6, align 8 call void @Microsoft__Quantum__Intrinsic__CNOT__ctl(%Array* %__controlQubits__, { %Qubit*, %Qubit* }* %4) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %3, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %3, i32 -1) ret void } declare %Tuple* @__quantum__rt__tuple_create(i64) -declare void @__quantum__rt__tuple_update_reference_count(%Tuple*, i64) +declare void @__quantum__rt__tuple_update_reference_count(%Tuple*, i32) define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qb) { entry: @@ -222,8 +384,6 @@ entry: ret void } -declare void @__quantum__qis__single_qubit_op(i64, i64, %Qubit*) - define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qb) { entry: call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb) @@ -232,19 +392,19 @@ entry: define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) ret void } @@ -254,18 +414,16 @@ entry: ret %Result* %0 } -declare %Result* @__quantum__qis__single_qubit_measure(i64, i64, %Qubit*) - define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %paulis, %Array* %qubits) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = load %Result*, %Result** @ResultOne - %res = alloca %Result* - store %Result* %0, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %0, i64 1) - %haveY = alloca i1 - store i1 false, i1* %haveY + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) + %0 = call %Result* @__quantum__rt__result_get_one() + %res = alloca %Result*, align 8 + store %Result* %0, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %0, i32 1) + %haveY = alloca i1, align 1 + store i1 false, i1* %haveY, align 1 %1 = call i64 @__quantum__rt__array_get_size_1d(%Array* %paulis) %2 = sub i64 %1, 1 br label %header__1 @@ -278,22 +436,28 @@ header__1: ; preds = %exiting__1, %entry body__1: ; preds = %header__1 %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) %5 = bitcast i8* %4 to i2* - %6 = load i2, i2* %5 - %7 = load i2, i2* @PauliY + %6 = load i2, i2* %5, align 1 + %7 = load i2, i2* @PauliY, align 1 %8 = icmp eq i2 %6, %7 + br i1 %8, label %condContinue__1, label %condFalse__1 + +condFalse__1: ; preds = %body__1 %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) %10 = bitcast i8* %9 to i2* - %11 = load i2, i2* %10 - %12 = load i2, i2* @PauliI + %11 = load i2, i2* %10, align 1 + %12 = load i2, i2* @PauliI, align 1 %13 = icmp eq i2 %11, %12 - %14 = or i1 %8, %13 + br label %condContinue__1 + +condContinue__1: ; preds = %condFalse__1, %body__1 + %14 = phi i1 [ %8, %body__1 ], [ %13, %condFalse__1 ] br i1 %14, label %then0__1, label %continue__1 -then0__1: ; preds = %body__1 - store i1 true, i1* %haveY +then0__1: ; preds = %condContinue__1 + store i1 true, i1* %haveY, align 1 br label %continue__1 -continue__1: ; preds = %then0__1, %body__1 +continue__1: ; preds = %then0__1, %condContinue__1 br label %exiting__1 exiting__1: ; preds = %continue__1 @@ -301,15 +465,15 @@ exiting__1: ; preds = %continue__1 br label %header__1 exit__1: ; preds = %header__1 - %16 = load i1, i1* %haveY + %16 = load i1, i1* %haveY, align 1 br i1 %16, label %then0__2, label %test1__1 then0__2: ; preds = %exit__1 %17 = call %Result* @__quantum__qis__joint_measure(i64 106, i64 1, %Array* %qubits) - call void @__quantum__rt__result_update_reference_count(%Result* %17, i64 1) - store %Result* %17, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %17, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %0, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 1) + store %Result* %17, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %0, i32 -1) br label %continue__2 test1__1: ; preds = %exit__1 @@ -318,11 +482,11 @@ test1__1: ; preds = %exit__1 then1__1: ; preds = %test1__1 %19 = call %Result* @__quantum__qis__joint_measure(i64 107, i64 1, %Array* %qubits) - call void @__quantum__rt__result_update_reference_count(%Result* %19, i64 1) - %20 = load %Result*, %Result** %res - store %Result* %19, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %19, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %20, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %19, i32 1) + %20 = load %Result*, %Result** %res, align 8 + store %Result* %19, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %19, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %20, i32 -1) br label %continue__2 test2__1: ; preds = %test1__1 @@ -332,33 +496,33 @@ test2__1: ; preds = %test1__1 then2__1: ; preds = %test2__1 %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %23 = bitcast i8* %22 to i2* - %24 = load i2, i2* %23 - %25 = load i2, i2* @PauliX + %24 = load i2, i2* %23, align 1 + %25 = load i2, i2* @PauliX, align 1 %26 = icmp eq i2 %24, %25 br i1 %26, label %then0__3, label %else__1 then0__3: ; preds = %then2__1 %27 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) %28 = bitcast i8* %27 to %Qubit** - %qb = load %Qubit*, %Qubit** %28 + %qb = load %Qubit*, %Qubit** %28, align 8 %29 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb) - call void @__quantum__rt__result_update_reference_count(%Result* %29, i64 1) - %30 = load %Result*, %Result** %res - store %Result* %29, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %29, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %30, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %29, i32 1) + %30 = load %Result*, %Result** %res, align 8 + store %Result* %29, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %29, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %30, i32 -1) br label %continue__3 else__1: ; preds = %then2__1 %31 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) %32 = bitcast i8* %31 to %Qubit** - %qb__1 = load %Qubit*, %Qubit** %32 + %qb__1 = load %Qubit*, %Qubit** %32, align 8 %33 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__1) - call void @__quantum__rt__result_update_reference_count(%Result* %33, i64 1) - %34 = load %Result*, %Result** %res - store %Result* %33, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %33, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %34, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %33, i32 1) + %34 = load %Result*, %Result** %res, align 8 + store %Result* %33, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %33, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %34, i32 -1) br label %continue__3 continue__3: ; preds = %else__1, %then0__3 @@ -367,111 +531,135 @@ continue__3: ; preds = %else__1, %then0__3 test3__1: ; preds = %test2__1 %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %36 = bitcast i8* %35 to i2* - %37 = load i2, i2* %36 - %38 = load i2, i2* @PauliX + %37 = load i2, i2* %36, align 1 + %38 = load i2, i2* @PauliX, align 1 %39 = icmp eq i2 %37, %38 + br i1 %39, label %condTrue__1, label %condContinue__2 + +condTrue__1: ; preds = %test3__1 %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %41 = bitcast i8* %40 to i2* - %42 = load i2, i2* %41 - %43 = load i2, i2* @PauliX + %42 = load i2, i2* %41, align 1 + %43 = load i2, i2* @PauliX, align 1 %44 = icmp eq i2 %42, %43 - %45 = and i1 %39, %44 + br label %condContinue__2 + +condContinue__2: ; preds = %condTrue__1, %test3__1 + %45 = phi i1 [ %44, %condTrue__1 ], [ %39, %test3__1 ] br i1 %45, label %then3__1, label %test4__1 -then3__1: ; preds = %test3__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) +then3__1: ; preds = %condContinue__2 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) %46 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %46, i64 1) - %47 = load %Result*, %Result** %res - store %Result* %46, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %46, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %47, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %46, i32 1) + %47 = load %Result*, %Result** %res, align 8 + store %Result* %46, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %46, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %47, i32 -1) br label %continue__2 -test4__1: ; preds = %test3__1 +test4__1: ; preds = %condContinue__2 %48 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %49 = bitcast i8* %48 to i2* - %50 = load i2, i2* %49 - %51 = load i2, i2* @PauliX + %50 = load i2, i2* %49, align 1 + %51 = load i2, i2* @PauliX, align 1 %52 = icmp eq i2 %50, %51 + br i1 %52, label %condTrue__2, label %condContinue__3 + +condTrue__2: ; preds = %test4__1 %53 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %54 = bitcast i8* %53 to i2* - %55 = load i2, i2* %54 - %56 = load i2, i2* @PauliZ + %55 = load i2, i2* %54, align 1 + %56 = load i2, i2* @PauliZ, align 1 %57 = icmp eq i2 %55, %56 - %58 = and i1 %52, %57 + br label %condContinue__3 + +condContinue__3: ; preds = %condTrue__2, %test4__1 + %58 = phi i1 [ %57, %condTrue__2 ], [ %52, %test4__1 ] br i1 %58, label %then4__1, label %test5__1 -then4__1: ; preds = %test4__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) +then4__1: ; preds = %condContinue__3 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) %59 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %59, i64 1) - %60 = load %Result*, %Result** %res - store %Result* %59, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %59, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %60, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %59, i32 1) + %60 = load %Result*, %Result** %res, align 8 + store %Result* %59, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %59, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %60, i32 -1) br label %continue__2 -test5__1: ; preds = %test4__1 +test5__1: ; preds = %condContinue__3 %61 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %62 = bitcast i8* %61 to i2* - %63 = load i2, i2* %62 - %64 = load i2, i2* @PauliZ + %63 = load i2, i2* %62, align 1 + %64 = load i2, i2* @PauliZ, align 1 %65 = icmp eq i2 %63, %64 + br i1 %65, label %condTrue__3, label %condContinue__4 + +condTrue__3: ; preds = %test5__1 %66 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %67 = bitcast i8* %66 to i2* - %68 = load i2, i2* %67 - %69 = load i2, i2* @PauliX + %68 = load i2, i2* %67, align 1 + %69 = load i2, i2* @PauliX, align 1 %70 = icmp eq i2 %68, %69 - %71 = and i1 %65, %70 + br label %condContinue__4 + +condContinue__4: ; preds = %condTrue__3, %test5__1 + %71 = phi i1 [ %70, %condTrue__3 ], [ %65, %test5__1 ] br i1 %71, label %then5__1, label %test6__1 -then5__1: ; preds = %test5__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) +then5__1: ; preds = %condContinue__4 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) %72 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %72, i64 1) - %73 = load %Result*, %Result** %res - store %Result* %72, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %72, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %73, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %72, i32 1) + %73 = load %Result*, %Result** %res, align 8 + store %Result* %72, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %72, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %73, i32 -1) br label %continue__2 -test6__1: ; preds = %test5__1 +test6__1: ; preds = %condContinue__4 %74 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %75 = bitcast i8* %74 to i2* - %76 = load i2, i2* %75 - %77 = load i2, i2* @PauliZ + %76 = load i2, i2* %75, align 1 + %77 = load i2, i2* @PauliZ, align 1 %78 = icmp eq i2 %76, %77 + br i1 %78, label %condTrue__4, label %condContinue__5 + +condTrue__4: ; preds = %test6__1 %79 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %80 = bitcast i8* %79 to i2* - %81 = load i2, i2* %80 - %82 = load i2, i2* @PauliZ + %81 = load i2, i2* %80, align 1 + %82 = load i2, i2* @PauliZ, align 1 %83 = icmp eq i2 %81, %82 - %84 = and i1 %78, %83 + br label %condContinue__5 + +condContinue__5: ; preds = %condTrue__4, %test6__1 + %84 = phi i1 [ %83, %condTrue__4 ], [ %78, %test6__1 ] br i1 %84, label %then6__1, label %continue__2 -then6__1: ; preds = %test6__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) +then6__1: ; preds = %condContinue__5 + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) %85 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %85, i64 1) - %86 = load %Result*, %Result** %res - store %Result* %85, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %85, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %86, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %85, i32 1) + %86 = load %Result*, %Result** %res, align 8 + store %Result* %85, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %85, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %86, i32 -1) br label %continue__2 -continue__2: ; preds = %then6__1, %test6__1, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 - %87 = load %Result*, %Result** %res - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) +continue__2: ; preds = %then6__1, %condContinue__5, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 + %87 = load %Result*, %Result** %res, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) ret %Result* %87 } -declare %Result* @__quantum__qis__joint_measure(i64, i64, %Array*) +declare %Result* @__quantum__rt__result_get_one() define void @Microsoft__Quantum__Intrinsic__Rx__body(double %theta, %Qubit* %qb) { entry: @@ -487,25 +675,25 @@ entry: define void @Microsoft__Quantum__Intrinsic__Rx__ctl(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__Rx__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -523,25 +711,25 @@ entry: define void @Microsoft__Quantum__Intrinsic__Ry__ctl(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__Ry__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -559,25 +747,25 @@ entry: define void @Microsoft__Quantum__Intrinsic__Rz__ctl(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__Rz__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1 + %theta = load double, double* %1, align 8 %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2 + %qb = load %Qubit*, %Qubit** %2, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -595,21 +783,21 @@ entry: define void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -627,21 +815,21 @@ entry: define void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } @@ -659,7 +847,7 @@ entry: define void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -673,14 +861,14 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -694,8 +882,8 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) ret void } @@ -713,7 +901,7 @@ entry: define void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -727,14 +915,14 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -748,8 +936,8 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) ret void } @@ -767,7 +955,7 @@ entry: define void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %ctls, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -781,14 +969,14 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) ret void } define void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) %1 = icmp eq i64 %0, 1 br i1 %1, label %then0__1, label %else__1 @@ -802,194 +990,23 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i64 -1) - ret void -} - -define %Tuple* @Microsoft__Quantum__Core__Attribute__body() { -entry: - ret %Tuple* null -} - -define %Tuple* @Microsoft__Quantum__Core__EntryPoint__body() { -entry: - ret %Tuple* null -} - -define %Tuple* @Microsoft__Quantum__Core__Inline__body() { -entry: - ret %Tuple* null -} - -define %Result* @Microsoft__Quantum__Instructions__Mx__body(%Qubit* %qb) { -entry: - %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mxx__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mxz__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mz__body(%Qubit* %qb) { -entry: - %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mzx__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mzz__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i64 -1) - ret %Result* %0 -} - -define void @Microsoft__Quantum__Instructions__Sx__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sx__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sx__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sx__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) ret void } define void @Microsoft__Quantum__Testing__Tracer__Delay__body(%Callable* %op, %Qubit* %arg, %Tuple* %aux) { entry: - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %op, i64 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i64 1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 1) %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) %1 = bitcast %Tuple* %0 to { %Qubit* }* %2 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %1, i32 0, i32 0 - store %Qubit* %arg, %Qubit** %2 + store %Qubit* %arg, %Qubit** %2, align 8 call void @__quantum__rt__callable_invoke(%Callable* %op, %Tuple* %0, %Tuple* null) - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %op, i64 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i64 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %0, i64 -1) + call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 -1) + call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %0, i32 -1) ret void } @@ -998,103 +1015,103 @@ declare void @__quantum__rt__callable_invoke(%Callable*, %Tuple*, %Tuple*) define void @Microsoft__Quantum__Testing__Tracer__TestCoreIntrinsics__body() { entry: %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 3) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %1 = bitcast i8* %0 to %Qubit** - %qb = load %Qubit*, %Qubit** %1 + %qb = load %Qubit*, %Qubit** %1, align 8 call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb) %2 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %3 = bitcast i8* %2 to %Qubit** - %qb__1 = load %Qubit*, %Qubit** %3 + %qb__1 = load %Qubit*, %Qubit** %3, align 8 call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb__1) %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %5 = bitcast i8* %4 to %Qubit** - %qb__2 = load %Qubit*, %Qubit** %5 + %qb__2 = load %Qubit*, %Qubit** %5, align 8 call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb__2) %6 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %7 = bitcast i8* %6 to %Qubit** - %qb__3 = load %Qubit*, %Qubit** %7 + %qb__3 = load %Qubit*, %Qubit** %7, align 8 call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb__3) %8 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %9 = bitcast i8* %8 to %Qubit** - %10 = load %Qubit*, %Qubit** %9 + %10 = load %Qubit*, %Qubit** %9, align 8 %11 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %12 = bitcast i8* %11 to %Qubit** - %13 = load %Qubit*, %Qubit** %12 + %13 = load %Qubit*, %Qubit** %12, align 8 call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %10, %Qubit* %13) %14 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %15 = bitcast i8* %14 to %Qubit** - %qb__4 = load %Qubit*, %Qubit** %15 + %qb__4 = load %Qubit*, %Qubit** %15, align 8 call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__4) %16 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %17 = bitcast i8* %16 to %Qubit** - %qb__5 = load %Qubit*, %Qubit** %17 + %qb__5 = load %Qubit*, %Qubit** %17, align 8 call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb__5) %18 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %19 = bitcast i8* %18 to %Qubit** - %qb__6 = load %Qubit*, %Qubit** %19 + %qb__6 = load %Qubit*, %Qubit** %19, align 8 call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb__6) %20 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %21 = bitcast i8* %20 to %Qubit** - %qb__7 = load %Qubit*, %Qubit** %21 + %qb__7 = load %Qubit*, %Qubit** %21, align 8 call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb__7) %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %23 = bitcast i8* %22 to %Qubit** - %qb__9 = load %Qubit*, %Qubit** %23 + %qb__9 = load %Qubit*, %Qubit** %23, align 8 call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__9) call void @__quantum__qis__inject_barrier(i64 42, i64 0) %24 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %25 = bitcast i8* %24 to %Qubit** - %qb__11 = load %Qubit*, %Qubit** %25 + %qb__11 = load %Qubit*, %Qubit** %25, align 8 call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb__11) %26 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %27 = bitcast i8* %26 to %Qubit** - %qb__13 = load %Qubit*, %Qubit** %27 + %qb__13 = load %Qubit*, %Qubit** %27, align 8 call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb__13) %28 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %29 = bitcast i8* %28 to %Qubit** - %qb__15 = load %Qubit*, %Qubit** %29 + %qb__15 = load %Qubit*, %Qubit** %29, align 8 call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb__15) %30 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %31 = bitcast i8* %30 to %Qubit** - %qb__17 = load %Qubit*, %Qubit** %31 + %qb__17 = load %Qubit*, %Qubit** %31, align 8 call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb__17) %32 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %33 = bitcast i8* %32 to %Qubit** - %34 = load %Qubit*, %Qubit** %33 + %34 = load %Qubit*, %Qubit** %33, align 8 %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %36 = bitcast i8* %35 to %Qubit** - %37 = load %Qubit*, %Qubit** %36 + %37 = load %Qubit*, %Qubit** %36, align 8 call void @Microsoft__Quantum__Intrinsic__CNOT__adj(%Qubit* %34, %Qubit* %37) %38 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %39 = bitcast i8* %38 to %Qubit** - %qb__19 = load %Qubit*, %Qubit** %39 + %qb__19 = load %Qubit*, %Qubit** %39, align 8 call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__19) %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %41 = bitcast i8* %40 to %Qubit** - %qb__20 = load %Qubit*, %Qubit** %41 + %qb__20 = load %Qubit*, %Qubit** %41, align 8 call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb__20) %42 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %43 = bitcast i8* %42 to %Qubit** - %qb__21 = load %Qubit*, %Qubit** %43 + %qb__21 = load %Qubit*, %Qubit** %43, align 8 call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb__21) %44 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %45 = bitcast i8* %44 to %Qubit** - %qb__22 = load %Qubit*, %Qubit** %45 + %qb__22 = load %Qubit*, %Qubit** %45, align 8 call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb__22) %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %47 = bitcast i8* %46 to %Qubit** - %qb__24 = load %Qubit*, %Qubit** %47 + %qb__24 = load %Qubit*, %Qubit** %47, align 8 call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__24) %c = call %Qubit* @__quantum__rt__qubit_allocate() %ctls = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %48 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) %49 = bitcast i8* %48 to %Qubit** - store %Qubit* %c, %Qubit** %49 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 1) + store %Qubit* %c, %Qubit** %49, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) %50 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %51 = bitcast i8* %50 to %Qubit** - %qb__26 = load %Qubit*, %Qubit** %51 + %qb__26 = load %Qubit*, %Qubit** %51, align 8 br i1 true, label %then0__1, label %else__1 then0__1: ; preds = %entry @@ -1106,16 +1123,16 @@ else__1: ; preds = %entry br label %continue__1 continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i32 -1) %ctls__1 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %52 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__1, i64 0) %53 = bitcast i8* %52 to %Qubit** - store %Qubit* %c, %Qubit** %53 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i64 1) + store %Qubit* %c, %Qubit** %53, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 1) %54 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %55 = bitcast i8* %54 to %Qubit** - %qb__27 = load %Qubit*, %Qubit** %55 + %qb__27 = load %Qubit*, %Qubit** %55, align 8 br i1 true, label %then0__2, label %else__2 then0__2: ; preds = %continue__1 @@ -1127,16 +1144,16 @@ else__2: ; preds = %continue__1 br label %continue__2 continue__2: ; preds = %else__2, %then0__2 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i32 -1) %ctls__2 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %56 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__2, i64 0) %57 = bitcast i8* %56 to %Qubit** - store %Qubit* %c, %Qubit** %57 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i64 1) + store %Qubit* %c, %Qubit** %57, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i32 1) %58 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %59 = bitcast i8* %58 to %Qubit** - %qb__28 = load %Qubit*, %Qubit** %59 + %qb__28 = load %Qubit*, %Qubit** %59, align 8 br i1 true, label %then0__3, label %else__3 then0__3: ; preds = %continue__2 @@ -1148,85 +1165,85 @@ else__3: ; preds = %continue__2 br label %continue__3 continue__3: ; preds = %else__3, %then0__3 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__2, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__2, i32 -1) %ctls__3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %60 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__3, i64 0) %61 = bitcast i8* %60 to %Qubit** - store %Qubit* %c, %Qubit** %61 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i64 1) + store %Qubit* %c, %Qubit** %61, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i32 1) %62 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %63 = bitcast i8* %62 to %Qubit** - %qb__29 = load %Qubit*, %Qubit** %63 + %qb__29 = load %Qubit*, %Qubit** %63, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %ctls__3, %Qubit* %qb__29) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__3, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__3, i32 -1) %ctls__4 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %64 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__4, i64 0) %65 = bitcast i8* %64 to %Qubit** - store %Qubit* %c, %Qubit** %65 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i64 1) + store %Qubit* %c, %Qubit** %65, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i32 1) %66 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %67 = bitcast i8* %66 to %Qubit** - %qb__30 = load %Qubit*, %Qubit** %67 + %qb__30 = load %Qubit*, %Qubit** %67, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls__4, %Qubit* %qb__30) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__4, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__4, i32 -1) %ctls__5 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %68 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__5, i64 0) %69 = bitcast i8* %68 to %Qubit** - store %Qubit* %c, %Qubit** %69 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i64 1) + store %Qubit* %c, %Qubit** %69, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i32 1) %70 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %71 = bitcast i8* %70 to %Qubit** - %qb__31 = load %Qubit*, %Qubit** %71 + %qb__31 = load %Qubit*, %Qubit** %71, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls__5, %Qubit* %qb__31) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__5, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__5, i32 -1) %ctls__6 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %72 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__6, i64 0) %73 = bitcast i8* %72 to %Qubit** - store %Qubit* %c, %Qubit** %73 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i64 1) + store %Qubit* %c, %Qubit** %73, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i32 1) %74 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %75 = bitcast i8* %74 to %Qubit** - %qb__32 = load %Qubit*, %Qubit** %75 + %qb__32 = load %Qubit*, %Qubit** %75, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls__6, %Qubit* %qb__32) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__6, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__6, i32 -1) %ctls__7 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %76 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__7, i64 0) %77 = bitcast i8* %76 to %Qubit** - store %Qubit* %c, %Qubit** %77 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i64 1) + store %Qubit* %c, %Qubit** %77, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 1) %78 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %79 = bitcast i8* %78 to %Qubit** - %qb__33 = load %Qubit*, %Qubit** %79 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i64 1) + %qb__33 = load %Qubit*, %Qubit** %79, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls__7, %Qubit* %qb__33) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__7, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__7, i32 -1) %ctls__9 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) %80 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__9, i64 0) %81 = bitcast i8* %80 to %Qubit** - store %Qubit* %c, %Qubit** %81 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i64 1) + store %Qubit* %c, %Qubit** %81, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 1) %82 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %83 = bitcast i8* %82 to %Qubit** - %qb__35 = load %Qubit*, %Qubit** %83 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i64 1) + %qb__35 = load %Qubit*, %Qubit** %83, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls__9, %Qubit* %qb__35) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__9, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %ctls__9, i32 -1) call void @__quantum__rt__qubit_release(%Qubit* %c) %cc = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %84 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %85 = bitcast i8* %84 to %Qubit** - %qb__37 = load %Qubit*, %Qubit** %85 + %qb__37 = load %Qubit*, %Qubit** %85, align 8 %86 = call i64 @__quantum__rt__array_get_size_1d(%Array* %cc) %87 = icmp eq i64 %86, 1 br i1 %87, label %then0__4, label %else__4 @@ -1240,11 +1257,11 @@ else__4: ; preds = %continue__3 br label %continue__4 continue__4: ; preds = %else__4, %then0__4 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %88 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %89 = bitcast i8* %88 to %Qubit** - %qb__38 = load %Qubit*, %Qubit** %89 + %qb__38 = load %Qubit*, %Qubit** %89, align 8 %90 = icmp eq i64 %86, 1 br i1 %90, label %then0__5, label %else__5 @@ -1257,11 +1274,11 @@ else__5: ; preds = %continue__4 br label %continue__5 continue__5: ; preds = %else__5, %then0__5 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %91 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %92 = bitcast i8* %91 to %Qubit** - %qb__39 = load %Qubit*, %Qubit** %92 + %qb__39 = load %Qubit*, %Qubit** %92, align 8 %93 = icmp eq i64 %86, 1 br i1 %93, label %then0__6, label %else__6 @@ -1274,53 +1291,51 @@ else__6: ; preds = %continue__5 br label %continue__6 continue__6: ; preds = %else__6, %then0__6 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %94 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %95 = bitcast i8* %94 to %Qubit** - %qb__40 = load %Qubit*, %Qubit** %95 + %qb__40 = load %Qubit*, %Qubit** %95, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %cc, %Qubit* %qb__40) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %96 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %97 = bitcast i8* %96 to %Qubit** - %qb__41 = load %Qubit*, %Qubit** %97 + %qb__41 = load %Qubit*, %Qubit** %97, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %cc, %Qubit* %qb__41) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %98 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %99 = bitcast i8* %98 to %Qubit** - %qb__42 = load %Qubit*, %Qubit** %99 + %qb__42 = load %Qubit*, %Qubit** %99, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %cc, %Qubit* %qb__42) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %100 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %101 = bitcast i8* %100 to %Qubit** - %qb__43 = load %Qubit*, %Qubit** %101 + %qb__43 = load %Qubit*, %Qubit** %101, align 8 call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %cc, %Qubit* %qb__43) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %102 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %103 = bitcast i8* %102 to %Qubit** - %qb__44 = load %Qubit*, %Qubit** %103 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + %qb__44 = load %Qubit*, %Qubit** %103, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %cc, %Qubit* %qb__44) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) %104 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %105 = bitcast i8* %104 to %Qubit** - %qb__46 = load %Qubit*, %Qubit** %105 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 1) + %qb__46 = load %Qubit*, %Qubit** %105, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %cc, %Qubit* %qb__46) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) call void @__quantum__rt__qubit_release_array(%Array* %cc) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %cc, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) call void @__quantum__rt__qubit_release_array(%Array* %qs) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qs, i64 -1) ret void } @@ -1337,25 +1352,25 @@ declare void @__quantum__rt__qubit_release_array(%Array*) define void @Microsoft__Quantum__Testing__Tracer__TestMeasurements__body() { entry: %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 6) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %1 = bitcast i8* %0 to %Qubit** - %qb = load %Qubit*, %Qubit** %1 + %qb = load %Qubit*, %Qubit** %1, align 8 call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) %2 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) %3 = bitcast i8* %2 to %Qubit** - %qb__2 = load %Qubit*, %Qubit** %3 + %qb__2 = load %Qubit*, %Qubit** %3, align 8 %r0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__2) %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %5 = bitcast i8* %4 to %Qubit** - %qb__4 = load %Qubit*, %Qubit** %5 + %qb__4 = load %Qubit*, %Qubit** %5, align 8 call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__4) %6 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %7 = bitcast i8* %6 to %Qubit** - %8 = load %Qubit*, %Qubit** %7 + %8 = load %Qubit*, %Qubit** %7, align 8 %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %10 = bitcast i8* %9 to %Qubit** - %11 = load %Qubit*, %Qubit** %10 + %11 = load %Qubit*, %Qubit** %10, align 8 call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %8, %Qubit* %11) %qs12 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 2) %12 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) @@ -1364,30 +1379,30 @@ entry: %15 = bitcast i8* %14 to %Qubit** %16 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) %17 = bitcast i8* %16 to %Qubit** - %18 = load %Qubit*, %Qubit** %17 + %18 = load %Qubit*, %Qubit** %17, align 8 %19 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) %20 = bitcast i8* %19 to %Qubit** - %21 = load %Qubit*, %Qubit** %20 - store %Qubit* %18, %Qubit** %13 - store %Qubit* %21, %Qubit** %15 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) + %21 = load %Qubit*, %Qubit** %20, align 8 + store %Qubit* %18, %Qubit** %13, align 8 + store %Qubit* %21, %Qubit** %15, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) %paulis = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %23 = bitcast i8* %22 to i2* %24 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %25 = bitcast i8* %24 to i2* - %26 = load i2, i2* @PauliY - %27 = load i2, i2* @PauliX - store i2 %26, i2* %23 - store i2 %27, i2* %25 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) - %28 = load %Result*, %Result** @ResultOne - %res = alloca %Result* - store %Result* %28, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %28, i64 1) - %haveY = alloca i1 - store i1 false, i1* %haveY + %26 = load i2, i2* @PauliY, align 1 + %27 = load i2, i2* @PauliX, align 1 + store i2 %26, i2* %23, align 1 + store i2 %27, i2* %25, align 1 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) + %28 = call %Result* @__quantum__rt__result_get_one() + %res = alloca %Result*, align 8 + store %Result* %28, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %28, i32 1) + %haveY = alloca i1, align 1 + store i1 false, i1* %haveY, align 1 br label %header__1 header__1: ; preds = %exiting__1, %entry @@ -1398,22 +1413,28 @@ header__1: ; preds = %exiting__1, %entry body__1: ; preds = %header__1 %30 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) %31 = bitcast i8* %30 to i2* - %32 = load i2, i2* %31 - %33 = load i2, i2* @PauliY + %32 = load i2, i2* %31, align 1 + %33 = load i2, i2* @PauliY, align 1 %34 = icmp eq i2 %32, %33 + br i1 %34, label %condContinue__1, label %condFalse__1 + +condFalse__1: ; preds = %body__1 %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) %36 = bitcast i8* %35 to i2* - %37 = load i2, i2* %36 - %38 = load i2, i2* @PauliI + %37 = load i2, i2* %36, align 1 + %38 = load i2, i2* @PauliI, align 1 %39 = icmp eq i2 %37, %38 - %40 = or i1 %34, %39 + br label %condContinue__1 + +condContinue__1: ; preds = %condFalse__1, %body__1 + %40 = phi i1 [ %34, %body__1 ], [ %39, %condFalse__1 ] br i1 %40, label %then0__1, label %continue__1 -then0__1: ; preds = %body__1 - store i1 true, i1* %haveY +then0__1: ; preds = %condContinue__1 + store i1 true, i1* %haveY, align 1 br label %continue__1 -continue__1: ; preds = %then0__1, %body__1 +continue__1: ; preds = %then0__1, %condContinue__1 br label %exiting__1 exiting__1: ; preds = %continue__1 @@ -1421,15 +1442,15 @@ exiting__1: ; preds = %continue__1 br label %header__1 exit__1: ; preds = %header__1 - %42 = load i1, i1* %haveY + %42 = load i1, i1* %haveY, align 1 br i1 %42, label %then0__2, label %test1__1 then0__2: ; preds = %exit__1 %43 = call %Result* @__quantum__qis__joint_measure(i64 106, i64 1, %Array* %qs12) - call void @__quantum__rt__result_update_reference_count(%Result* %43, i64 1) - store %Result* %43, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %43, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %28, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %43, i32 1) + store %Result* %43, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %43, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %28, i32 -1) br label %continue__2 test1__1: ; preds = %exit__1 @@ -1437,11 +1458,11 @@ test1__1: ; preds = %exit__1 then1__1: ; preds = %test1__1 %44 = call %Result* @__quantum__qis__joint_measure(i64 107, i64 1, %Array* %qs12) - call void @__quantum__rt__result_update_reference_count(%Result* %44, i64 1) - %45 = load %Result*, %Result** %res - store %Result* %44, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %44, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %45, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %44, i32 1) + %45 = load %Result*, %Result** %res, align 8 + store %Result* %44, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %44, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %45, i32 -1) br label %continue__2 test2__1: ; preds = %test1__1 @@ -1450,33 +1471,33 @@ test2__1: ; preds = %test1__1 then2__1: ; preds = %test2__1 %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %47 = bitcast i8* %46 to i2* - %48 = load i2, i2* %47 - %49 = load i2, i2* @PauliX + %48 = load i2, i2* %47, align 1 + %49 = load i2, i2* @PauliX, align 1 %50 = icmp eq i2 %48, %49 br i1 %50, label %then0__3, label %else__1 then0__3: ; preds = %then2__1 %51 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) %52 = bitcast i8* %51 to %Qubit** - %qb__6 = load %Qubit*, %Qubit** %52 + %qb__6 = load %Qubit*, %Qubit** %52, align 8 %53 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb__6) - call void @__quantum__rt__result_update_reference_count(%Result* %53, i64 1) - %54 = load %Result*, %Result** %res - store %Result* %53, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %53, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %54, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %53, i32 1) + %54 = load %Result*, %Result** %res, align 8 + store %Result* %53, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %53, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %54, i32 -1) br label %continue__3 else__1: ; preds = %then2__1 %55 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) %56 = bitcast i8* %55 to %Qubit** - %qb__7 = load %Qubit*, %Qubit** %56 + %qb__7 = load %Qubit*, %Qubit** %56, align 8 %57 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__7) - call void @__quantum__rt__result_update_reference_count(%Result* %57, i64 1) - %58 = load %Result*, %Result** %res - store %Result* %57, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %57, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %58, i64 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %57, i32 1) + %58 = load %Result*, %Result** %res, align 8 + store %Result* %57, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %57, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %58, i32 -1) br label %continue__3 continue__3: ; preds = %else__1, %then0__3 @@ -1485,185 +1506,208 @@ continue__3: ; preds = %else__1, %then0__3 test3__1: ; preds = %test2__1 %59 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %60 = bitcast i8* %59 to i2* - %61 = load i2, i2* %60 - %62 = load i2, i2* @PauliX + %61 = load i2, i2* %60, align 1 + %62 = load i2, i2* @PauliX, align 1 %63 = icmp eq i2 %61, %62 + br i1 %63, label %condTrue__1, label %condContinue__2 + +condTrue__1: ; preds = %test3__1 %64 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %65 = bitcast i8* %64 to i2* - %66 = load i2, i2* %65 - %67 = load i2, i2* @PauliX + %66 = load i2, i2* %65, align 1 + %67 = load i2, i2* @PauliX, align 1 %68 = icmp eq i2 %66, %67 - %69 = and i1 %63, %68 + br label %condContinue__2 + +condContinue__2: ; preds = %condTrue__1, %test3__1 + %69 = phi i1 [ %68, %condTrue__1 ], [ %63, %test3__1 ] br i1 %69, label %then3__1, label %test4__1 -then3__1: ; preds = %test3__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) +then3__1: ; preds = %condContinue__2 + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) %70 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %70, i64 1) - %71 = load %Result*, %Result** %res - store %Result* %70, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %70, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %71, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %70, i32 1) + %71 = load %Result*, %Result** %res, align 8 + store %Result* %70, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %70, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %71, i32 -1) br label %continue__2 -test4__1: ; preds = %test3__1 +test4__1: ; preds = %condContinue__2 %72 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %73 = bitcast i8* %72 to i2* - %74 = load i2, i2* %73 - %75 = load i2, i2* @PauliX + %74 = load i2, i2* %73, align 1 + %75 = load i2, i2* @PauliX, align 1 %76 = icmp eq i2 %74, %75 + br i1 %76, label %condTrue__2, label %condContinue__3 + +condTrue__2: ; preds = %test4__1 %77 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %78 = bitcast i8* %77 to i2* - %79 = load i2, i2* %78 - %80 = load i2, i2* @PauliZ + %79 = load i2, i2* %78, align 1 + %80 = load i2, i2* @PauliZ, align 1 %81 = icmp eq i2 %79, %80 - %82 = and i1 %76, %81 + br label %condContinue__3 + +condContinue__3: ; preds = %condTrue__2, %test4__1 + %82 = phi i1 [ %81, %condTrue__2 ], [ %76, %test4__1 ] br i1 %82, label %then4__1, label %test5__1 -then4__1: ; preds = %test4__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) +then4__1: ; preds = %condContinue__3 + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) %83 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %83, i64 1) - %84 = load %Result*, %Result** %res - store %Result* %83, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %83, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %84, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %83, i32 1) + %84 = load %Result*, %Result** %res, align 8 + store %Result* %83, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %83, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %84, i32 -1) br label %continue__2 -test5__1: ; preds = %test4__1 +test5__1: ; preds = %condContinue__3 %85 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %86 = bitcast i8* %85 to i2* - %87 = load i2, i2* %86 - %88 = load i2, i2* @PauliZ + %87 = load i2, i2* %86, align 1 + %88 = load i2, i2* @PauliZ, align 1 %89 = icmp eq i2 %87, %88 + br i1 %89, label %condTrue__3, label %condContinue__4 + +condTrue__3: ; preds = %test5__1 %90 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %91 = bitcast i8* %90 to i2* - %92 = load i2, i2* %91 - %93 = load i2, i2* @PauliX + %92 = load i2, i2* %91, align 1 + %93 = load i2, i2* @PauliX, align 1 %94 = icmp eq i2 %92, %93 - %95 = and i1 %89, %94 + br label %condContinue__4 + +condContinue__4: ; preds = %condTrue__3, %test5__1 + %95 = phi i1 [ %94, %condTrue__3 ], [ %89, %test5__1 ] br i1 %95, label %then5__1, label %test6__1 -then5__1: ; preds = %test5__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) +then5__1: ; preds = %condContinue__4 + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) %96 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %96, i64 1) - %97 = load %Result*, %Result** %res - store %Result* %96, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %96, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %97, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %96, i32 1) + %97 = load %Result*, %Result** %res, align 8 + store %Result* %96, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %96, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %97, i32 -1) br label %continue__2 -test6__1: ; preds = %test5__1 +test6__1: ; preds = %condContinue__4 %98 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) %99 = bitcast i8* %98 to i2* - %100 = load i2, i2* %99 - %101 = load i2, i2* @PauliZ + %100 = load i2, i2* %99, align 1 + %101 = load i2, i2* @PauliZ, align 1 %102 = icmp eq i2 %100, %101 + br i1 %102, label %condTrue__4, label %condContinue__5 + +condTrue__4: ; preds = %test6__1 %103 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) %104 = bitcast i8* %103 to i2* - %105 = load i2, i2* %104 - %106 = load i2, i2* @PauliZ + %105 = load i2, i2* %104, align 1 + %106 = load i2, i2* @PauliZ, align 1 %107 = icmp eq i2 %105, %106 - %108 = and i1 %102, %107 + br label %condContinue__5 + +condContinue__5: ; preds = %condTrue__4, %test6__1 + %108 = phi i1 [ %107, %condTrue__4 ], [ %102, %test6__1 ] br i1 %108, label %then6__1, label %continue__2 -then6__1: ; preds = %test6__1 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 1) +then6__1: ; preds = %condContinue__5 + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) %109 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %109, i64 1) - %110 = load %Result*, %Result** %res - store %Result* %109, %Result** %res - call void @__quantum__rt__result_update_reference_count(%Result* %109, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %110, i64 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %109, i32 1) + %110 = load %Result*, %Result** %res, align 8 + store %Result* %109, %Result** %res, align 8 + call void @__quantum__rt__result_update_reference_count(%Result* %109, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %110, i32 -1) br label %continue__2 -continue__2: ; preds = %then6__1, %test6__1, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 - %r12 = load %Result*, %Result** %res - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis, i64 -1) +continue__2: ; preds = %then6__1, %condContinue__5, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 + %r12 = load %Result*, %Result** %res, align 8 + call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %paulis, i32 -1) %111 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %112 = bitcast %Tuple* %111 to { %Callable*, %Callable*, %Qubit* }* %113 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 0 %114 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 1 %115 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 2 - %116 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) - %117 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__X, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %116 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %117 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__X, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %118 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 3) %119 = bitcast i8* %118 to %Qubit** - %120 = load %Qubit*, %Qubit** %119 - store %Callable* %116, %Callable** %113 - store %Callable* %117, %Callable** %114 - store %Qubit* %120, %Qubit** %115 - %121 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__1, [2 x void (%Tuple*, i64)*]* @MemoryManagement__1, %Tuple* %111) + %120 = load %Qubit*, %Qubit** %119, align 8 + store %Callable* %116, %Callable** %113, align 8 + store %Callable* %117, %Callable** %114, align 8 + store %Qubit* %120, %Qubit** %115, align 8 + %121 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__1, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %111) %122 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %123 = bitcast %Tuple* %122 to { %Callable*, %Callable*, %Qubit* }* %124 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 0 %125 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 1 %126 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 2 - %127 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) - %128 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Y, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %127 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %128 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Y, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %129 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 3) %130 = bitcast i8* %129 to %Qubit** - %131 = load %Qubit*, %Qubit** %130 - store %Callable* %127, %Callable** %124 - store %Callable* %128, %Callable** %125 - store %Qubit* %131, %Qubit** %126 - %132 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__2, [2 x void (%Tuple*, i64)*]* @MemoryManagement__1, %Tuple* %122) + %131 = load %Qubit*, %Qubit** %130, align 8 + store %Callable* %127, %Callable** %124, align 8 + store %Callable* %128, %Callable** %125, align 8 + store %Qubit* %131, %Qubit** %126, align 8 + %132 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__2, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %122) call void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %r0, %Callable* %121, %Callable* %132) %133 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %134 = bitcast %Tuple* %133 to { %Callable*, %Callable*, %Qubit* }* %135 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 0 %136 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 1 %137 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 2 - %138 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) - %139 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Z, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %138 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %139 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Z, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %140 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 4) %141 = bitcast i8* %140 to %Qubit** - %142 = load %Qubit*, %Qubit** %141 - store %Callable* %138, %Callable** %135 - store %Callable* %139, %Callable** %136 - store %Qubit* %142, %Qubit** %137 - %143 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__3, [2 x void (%Tuple*, i64)*]* @MemoryManagement__1, %Tuple* %133) + %142 = load %Qubit*, %Qubit** %141, align 8 + store %Callable* %138, %Callable** %135, align 8 + store %Callable* %139, %Callable** %136, align 8 + store %Qubit* %142, %Qubit** %137, align 8 + %143 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__3, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %133) %144 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %145 = bitcast %Tuple* %144 to { %Callable*, %Callable*, %Qubit* }* %146 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 0 %147 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 1 %148 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 2 - %149 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) - %150 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__S, [2 x void (%Tuple*, i64)*]* null, %Tuple* null) + %149 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) + %150 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__S, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) %151 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 4) %152 = bitcast i8* %151 to %Qubit** - %153 = load %Qubit*, %Qubit** %152 - store %Callable* %149, %Callable** %146 - store %Callable* %150, %Callable** %147 - store %Qubit* %153, %Qubit** %148 - %154 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__4, [2 x void (%Tuple*, i64)*]* @MemoryManagement__2, %Tuple* %144) + %153 = load %Qubit*, %Qubit** %152, align 8 + store %Callable* %149, %Callable** %146, align 8 + store %Callable* %150, %Callable** %147, align 8 + store %Qubit* %153, %Qubit** %148, align 8 + %154 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__4, [2 x void (%Tuple*, i32)*]* @MemoryManagement__2, %Tuple* %144) call void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %r12, %Callable* %143, %Callable* %154) %155 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 5) %156 = bitcast i8* %155 to %Qubit** - %qb__8 = load %Qubit*, %Qubit** %156 + %qb__8 = load %Qubit*, %Qubit** %156, align 8 call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__8) + call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) + call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %r0, i32 -1) + call void @__quantum__rt__array_update_reference_count(%Array* %qs12, i32 -1) + call void @__quantum__rt__result_update_reference_count(%Result* %r12, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %121, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %121, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %132, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %132, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %143, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %143, i32 -1) + call void @__quantum__rt__capture_update_reference_count(%Callable* %154, i32 -1) + call void @__quantum__rt__callable_update_reference_count(%Callable* %154, i32 -1) call void @__quantum__rt__qubit_release_array(%Array* %qs) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i64 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qs, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %r0, i64 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qs12, i64 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %r12, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %121, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %121, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %132, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %132, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %143, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %143, i64 -1) - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %154, i64 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %154, i64 -1) ret void } @@ -1673,20 +1717,20 @@ entry: %1 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 1 %3 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 2 - %4 = load %Callable*, %Callable** %1 - %5 = load %Qubit*, %Qubit** %2 - %6 = load %Tuple*, %Tuple** %3 + %4 = load %Callable*, %Callable** %1, align 8 + %5 = load %Qubit*, %Qubit** %2, align 8 + %6 = load %Tuple*, %Tuple** %3, align 8 call void @Microsoft__Quantum__Testing__Tracer__Delay__body(%Callable* %4, %Qubit* %5, %Tuple* %6) ret void } -declare %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]*, [2 x void (%Tuple*, i64)*]*, %Tuple*) +declare %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]*, [2 x void (%Tuple*, i32)*]*, %Tuple*) define void @Microsoft__Quantum__Intrinsic__X__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %2) ret void } @@ -1695,7 +1739,7 @@ define void @Microsoft__Quantum__Intrinsic__X__adj__wrapper(%Tuple* %capture-tup entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %2) ret void } @@ -1705,8 +1749,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1716,8 +1760,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1726,54 +1770,54 @@ define void @Lifted__PartialApplication__1__body__wrapper(%Tuple* %capture-tuple entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1 + %2 = load %Callable*, %Callable** %1, align 8 %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3 + %4 = load %Qubit*, %Qubit** %3, align 8 %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6 + %7 = load %Tuple*, %Tuple** %6, align 8 %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10 - store %Qubit* %4, %Qubit** %11 - store %Tuple* %7, %Tuple** %12 + store %Callable* %2, %Callable** %10, align 8 + store %Qubit* %4, %Qubit** %11, align 8 + store %Tuple* %7, %Tuple** %12, align 8 %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13 + %14 = load %Callable*, %Callable** %13, align 8 call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) ret void } -define void @MemoryManagement__1__RefCount(%Tuple* %capture-tuple, i64 %count-change) { +define void @MemoryManagement__1__RefCount(%Tuple* %capture-tuple, i32 %count-change) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %2, i64 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i64 %count-change) + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %4, i64 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i64 %count-change) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i64 %count-change) + %4 = load %Callable*, %Callable** %3, align 8 + call void @__quantum__rt__capture_update_reference_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) ret void } -define void @MemoryManagement__1__AliasCount(%Tuple* %capture-tuple, i64 %count-change) { +define void @MemoryManagement__1__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1 - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %2, i64 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i64 %count-change) + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3 - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %4, i64 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i64 %count-change) - call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i64 %count-change) + %4 = load %Callable*, %Callable** %3, align 8 + call void @__quantum__rt__capture_update_alias_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) ret void } @@ -1781,7 +1825,7 @@ define void @Microsoft__Quantum__Intrinsic__Y__body__wrapper(%Tuple* %capture-tu entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %2) ret void } @@ -1790,7 +1834,7 @@ define void @Microsoft__Quantum__Intrinsic__Y__adj__wrapper(%Tuple* %capture-tup entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %2) ret void } @@ -1800,8 +1844,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1811,8 +1855,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1821,24 +1865,24 @@ define void @Lifted__PartialApplication__2__body__wrapper(%Tuple* %capture-tuple entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1 + %2 = load %Callable*, %Callable** %1, align 8 %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3 + %4 = load %Qubit*, %Qubit** %3, align 8 %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6 + %7 = load %Tuple*, %Tuple** %6, align 8 %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10 - store %Qubit* %4, %Qubit** %11 - store %Tuple* %7, %Tuple** %12 + store %Callable* %2, %Callable** %10, align 8 + store %Qubit* %4, %Qubit** %11, align 8 + store %Tuple* %7, %Tuple** %12, align 8 %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13 + %14 = load %Callable*, %Callable** %13, align 8 call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) ret void } @@ -1846,7 +1890,7 @@ define void @Microsoft__Quantum__Intrinsic__Z__body__wrapper(%Tuple* %capture-tu entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %2) ret void } @@ -1855,7 +1899,7 @@ define void @Microsoft__Quantum__Intrinsic__Z__adj__wrapper(%Tuple* %capture-tup entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %2) ret void } @@ -1865,8 +1909,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1876,8 +1920,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1886,24 +1930,24 @@ define void @Lifted__PartialApplication__3__body__wrapper(%Tuple* %capture-tuple entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1 + %2 = load %Callable*, %Callable** %1, align 8 %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3 + %4 = load %Qubit*, %Qubit** %3, align 8 %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6 + %7 = load %Tuple*, %Tuple** %6, align 8 %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10 - store %Qubit* %4, %Qubit** %11 - store %Tuple* %7, %Tuple** %12 + store %Callable* %2, %Callable** %10, align 8 + store %Qubit* %4, %Qubit** %11, align 8 + store %Tuple* %7, %Tuple** %12, align 8 %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13 + %14 = load %Callable*, %Callable** %13, align 8 call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) ret void } @@ -1911,7 +1955,7 @@ define void @Microsoft__Quantum__Intrinsic__S__body__wrapper(%Tuple* %capture-tu entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %2) ret void } @@ -1920,7 +1964,7 @@ define void @Microsoft__Quantum__Intrinsic__S__adj__wrapper(%Tuple* %capture-tup entry: %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1 + %2 = load %Qubit*, %Qubit** %1, align 8 call void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %2) ret void } @@ -1930,8 +1974,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %3, %Qubit* %4) ret void } @@ -1941,8 +1985,8 @@ entry: %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1 - %4 = load %Qubit*, %Qubit** %2 + %3 = load %Array*, %Array** %1, align 8 + %4 = load %Qubit*, %Qubit** %2, align 8 call void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %3, %Qubit* %4) ret void } @@ -1951,69 +1995,86 @@ define void @Lifted__PartialApplication__4__body__wrapper(%Tuple* %capture-tuple entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1 + %2 = load %Callable*, %Callable** %1, align 8 %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3 + %4 = load %Qubit*, %Qubit** %3, align 8 %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6 + %7 = load %Tuple*, %Tuple** %6, align 8 %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10 - store %Qubit* %4, %Qubit** %11 - store %Tuple* %7, %Tuple** %12 + store %Callable* %2, %Callable** %10, align 8 + store %Qubit* %4, %Qubit** %11, align 8 + store %Tuple* %7, %Tuple** %12, align 8 %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13 + %14 = load %Callable*, %Callable** %13, align 8 call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i64 -1) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) ret void } -define void @MemoryManagement__2__RefCount(%Tuple* %capture-tuple, i64 %count-change) { +define void @MemoryManagement__2__RefCount(%Tuple* %capture-tuple, i32 %count-change) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %2, i64 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i64 %count-change) + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3 - call void @__quantum__rt__callable_memory_management(i32 0, %Callable* %4, i64 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i64 %count-change) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i64 %count-change) + %4 = load %Callable*, %Callable** %3, align 8 + call void @__quantum__rt__capture_update_reference_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) ret void } -define void @MemoryManagement__2__AliasCount(%Tuple* %capture-tuple, i64 %count-change) { +define void @MemoryManagement__2__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { entry: %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1 - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %2, i64 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i64 %count-change) + %2 = load %Callable*, %Callable** %1, align 8 + call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) + call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3 - call void @__quantum__rt__callable_memory_management(i32 1, %Callable* %4, i64 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i64 %count-change) - call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i64 %count-change) + %4 = load %Callable*, %Callable** %3, align 8 + call void @__quantum__rt__capture_update_alias_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i32 %count-change) + call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) ret void } -declare void @__quantum__rt__callable_update_reference_count(%Callable*, i64) +declare void @__quantum__rt__capture_update_reference_count(%Callable*, i32) + +declare void @__quantum__rt__callable_update_reference_count(%Callable*, i32) + +define %Tuple* @Microsoft__Quantum__Core__Attribute__body() { +entry: + ret %Tuple* null +} + +define %Tuple* @Microsoft__Quantum__Core__EntryPoint__body() { +entry: + ret %Tuple* null +} + +define %Tuple* @Microsoft__Quantum__Core__Inline__body() { +entry: + ret %Tuple* null +} define { %String* }* @Microsoft__Quantum__Targeting__TargetInstruction__body(%String* %__Item1__) { entry: %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) %1 = bitcast %Tuple* %0 to { %String* }* %2 = getelementptr inbounds { %String* }, { %String* }* %1, i32 0, i32 0 - store %String* %__Item1__, %String** %2 - call void @__quantum__rt__string_update_reference_count(%String* %__Item1__, i64 1) + store %String* %__Item1__, %String** %2, align 8 + call void @__quantum__rt__string_update_reference_count(%String* %__Item1__, i32 1) ret { %String* }* %1 } -declare void @__quantum__rt__string_update_reference_count(%String*, i64) +declare void @__quantum__rt__string_update_reference_count(%String*, i32) -declare void @__quantum__rt__tuple_update_alias_count(%Tuple*, i64) +declare void @__quantum__rt__tuple_update_alias_count(%Tuple*, i32) diff --git a/src/Simulation/CSharpGeneration/Microsoft.Quantum.CSharpGeneration.fsproj b/src/Simulation/CSharpGeneration/Microsoft.Quantum.CSharpGeneration.fsproj index dbcade9d0a4..c85fc9bce0b 100644 --- a/src/Simulation/CSharpGeneration/Microsoft.Quantum.CSharpGeneration.fsproj +++ b/src/Simulation/CSharpGeneration/Microsoft.Quantum.CSharpGeneration.fsproj @@ -22,7 +22,7 @@ - + diff --git a/src/Simulation/QCTraceSimulator.Tests/Tests.Microsoft.Quantum.Simulation.QCTraceSimulatorRuntime.csproj b/src/Simulation/QCTraceSimulator.Tests/Tests.Microsoft.Quantum.Simulation.QCTraceSimulatorRuntime.csproj index b9a9f23a05e..e4ddd55cd52 100644 --- a/src/Simulation/QCTraceSimulator.Tests/Tests.Microsoft.Quantum.Simulation.QCTraceSimulatorRuntime.csproj +++ b/src/Simulation/QCTraceSimulator.Tests/Tests.Microsoft.Quantum.Simulation.QCTraceSimulatorRuntime.csproj @@ -1,4 +1,4 @@ - + diff --git a/src/Simulation/QSharpCore/Microsoft.Quantum.QSharp.Core.csproj b/src/Simulation/QSharpCore/Microsoft.Quantum.QSharp.Core.csproj index 55f5296116c..a60a126486d 100644 --- a/src/Simulation/QSharpCore/Microsoft.Quantum.QSharp.Core.csproj +++ b/src/Simulation/QSharpCore/Microsoft.Quantum.QSharp.Core.csproj @@ -1,4 +1,4 @@ - + diff --git a/src/Simulation/QSharpFoundation/Microsoft.Quantum.QSharp.Foundation.csproj b/src/Simulation/QSharpFoundation/Microsoft.Quantum.QSharp.Foundation.csproj index 5f2739dc51b..90085eb17cd 100644 --- a/src/Simulation/QSharpFoundation/Microsoft.Quantum.QSharp.Foundation.csproj +++ b/src/Simulation/QSharpFoundation/Microsoft.Quantum.QSharp.Foundation.csproj @@ -1,4 +1,4 @@ - + diff --git a/src/Simulation/Simulators.Tests/TestProjects/HoneywellExe/HoneywellExe.csproj b/src/Simulation/Simulators.Tests/TestProjects/HoneywellExe/HoneywellExe.csproj index 8d6648d99bd..2298e68b6de 100644 --- a/src/Simulation/Simulators.Tests/TestProjects/HoneywellExe/HoneywellExe.csproj +++ b/src/Simulation/Simulators.Tests/TestProjects/HoneywellExe/HoneywellExe.csproj @@ -1,4 +1,4 @@ - + Exe diff --git a/src/Simulation/Simulators.Tests/TestProjects/IntrinsicTests/IntrinsicTests.csproj b/src/Simulation/Simulators.Tests/TestProjects/IntrinsicTests/IntrinsicTests.csproj index 5df0333fbfd..831091933c3 100644 --- a/src/Simulation/Simulators.Tests/TestProjects/IntrinsicTests/IntrinsicTests.csproj +++ b/src/Simulation/Simulators.Tests/TestProjects/IntrinsicTests/IntrinsicTests.csproj @@ -1,4 +1,4 @@ - + netcoreapp3.1 diff --git a/src/Simulation/Simulators.Tests/TestProjects/IonQExe/IonQExe.csproj b/src/Simulation/Simulators.Tests/TestProjects/IonQExe/IonQExe.csproj index 155c413dd90..e25ff063324 100644 --- a/src/Simulation/Simulators.Tests/TestProjects/IonQExe/IonQExe.csproj +++ b/src/Simulation/Simulators.Tests/TestProjects/IonQExe/IonQExe.csproj @@ -1,4 +1,4 @@ - + Exe diff --git a/src/Simulation/Simulators.Tests/TestProjects/Library with Spaces/Library with Spaces.csproj b/src/Simulation/Simulators.Tests/TestProjects/Library with Spaces/Library with Spaces.csproj index 967fdc57f93..1efd1964b47 100644 --- a/src/Simulation/Simulators.Tests/TestProjects/Library with Spaces/Library with Spaces.csproj +++ b/src/Simulation/Simulators.Tests/TestProjects/Library with Spaces/Library with Spaces.csproj @@ -1,4 +1,4 @@ - + netstandard2.1 false diff --git a/src/Simulation/Simulators.Tests/TestProjects/Library1/Library1.csproj b/src/Simulation/Simulators.Tests/TestProjects/Library1/Library1.csproj index 3be0a69493f..45a59010ce2 100644 --- a/src/Simulation/Simulators.Tests/TestProjects/Library1/Library1.csproj +++ b/src/Simulation/Simulators.Tests/TestProjects/Library1/Library1.csproj @@ -1,4 +1,4 @@ - + netstandard2.1 diff --git a/src/Simulation/Simulators.Tests/TestProjects/Library2/Library2.csproj b/src/Simulation/Simulators.Tests/TestProjects/Library2/Library2.csproj index 3be0a69493f..45a59010ce2 100644 --- a/src/Simulation/Simulators.Tests/TestProjects/Library2/Library2.csproj +++ b/src/Simulation/Simulators.Tests/TestProjects/Library2/Library2.csproj @@ -1,4 +1,4 @@ - + netstandard2.1 diff --git a/src/Simulation/Simulators.Tests/TestProjects/QCIExe/QCIExe.csproj b/src/Simulation/Simulators.Tests/TestProjects/QCIExe/QCIExe.csproj index 10e31d76d29..f364193203a 100644 --- a/src/Simulation/Simulators.Tests/TestProjects/QCIExe/QCIExe.csproj +++ b/src/Simulation/Simulators.Tests/TestProjects/QCIExe/QCIExe.csproj @@ -1,4 +1,4 @@ - + Exe diff --git a/src/Simulation/Simulators.Tests/TestProjects/QSharpExe/QSharpExe.csproj b/src/Simulation/Simulators.Tests/TestProjects/QSharpExe/QSharpExe.csproj index 46fffc1465e..882c9fff161 100644 --- a/src/Simulation/Simulators.Tests/TestProjects/QSharpExe/QSharpExe.csproj +++ b/src/Simulation/Simulators.Tests/TestProjects/QSharpExe/QSharpExe.csproj @@ -1,4 +1,4 @@ - + Exe diff --git a/src/Simulation/Simulators.Tests/TestProjects/TargetedExe/TargetedExe.csproj b/src/Simulation/Simulators.Tests/TestProjects/TargetedExe/TargetedExe.csproj index efc6191b015..84a15bd4b68 100644 --- a/src/Simulation/Simulators.Tests/TestProjects/TargetedExe/TargetedExe.csproj +++ b/src/Simulation/Simulators.Tests/TestProjects/TargetedExe/TargetedExe.csproj @@ -1,4 +1,4 @@ - + Exe diff --git a/src/Simulation/Simulators.Tests/TestProjects/UnitTests/UnitTests.csproj b/src/Simulation/Simulators.Tests/TestProjects/UnitTests/UnitTests.csproj index 6e8e0d10e34..9361b91575d 100644 --- a/src/Simulation/Simulators.Tests/TestProjects/UnitTests/UnitTests.csproj +++ b/src/Simulation/Simulators.Tests/TestProjects/UnitTests/UnitTests.csproj @@ -1,4 +1,4 @@ - + netcoreapp3.1 diff --git a/src/Simulation/Simulators.Tests/Tests.Microsoft.Quantum.Simulators.csproj b/src/Simulation/Simulators.Tests/Tests.Microsoft.Quantum.Simulators.csproj index 281a717746a..5b2ca44efa6 100644 --- a/src/Simulation/Simulators.Tests/Tests.Microsoft.Quantum.Simulators.csproj +++ b/src/Simulation/Simulators.Tests/Tests.Microsoft.Quantum.Simulators.csproj @@ -1,4 +1,4 @@ - + diff --git a/src/Simulation/Simulators.Type1.Tests/Tests.Microsoft.Quantum.Simulators.Type1.csproj b/src/Simulation/Simulators.Type1.Tests/Tests.Microsoft.Quantum.Simulators.Type1.csproj index 48eae1fd4aa..f64f0332e09 100644 --- a/src/Simulation/Simulators.Type1.Tests/Tests.Microsoft.Quantum.Simulators.Type1.csproj +++ b/src/Simulation/Simulators.Type1.Tests/Tests.Microsoft.Quantum.Simulators.Type1.csproj @@ -1,4 +1,4 @@ - + diff --git a/src/Simulation/Simulators.Type2.Tests/Tests.Microsoft.Quantum.Simulators.Type2.csproj b/src/Simulation/Simulators.Type2.Tests/Tests.Microsoft.Quantum.Simulators.Type2.csproj index 4ecc2f5d180..11d8255db01 100644 --- a/src/Simulation/Simulators.Type2.Tests/Tests.Microsoft.Quantum.Simulators.Type2.csproj +++ b/src/Simulation/Simulators.Type2.Tests/Tests.Microsoft.Quantum.Simulators.Type2.csproj @@ -1,4 +1,4 @@ - + diff --git a/src/Simulation/Simulators.Type3.Tests/Tests.Microsoft.Quantum.Simulators.Type3.csproj b/src/Simulation/Simulators.Type3.Tests/Tests.Microsoft.Quantum.Simulators.Type3.csproj index 4de9084ec8b..6c104250bfb 100644 --- a/src/Simulation/Simulators.Type3.Tests/Tests.Microsoft.Quantum.Simulators.Type3.csproj +++ b/src/Simulation/Simulators.Type3.Tests/Tests.Microsoft.Quantum.Simulators.Type3.csproj @@ -1,4 +1,4 @@ - + diff --git a/src/Simulation/Simulators/Microsoft.Quantum.Simulators.csproj b/src/Simulation/Simulators/Microsoft.Quantum.Simulators.csproj index 2704eb6a47c..07b0313ed5c 100644 --- a/src/Simulation/Simulators/Microsoft.Quantum.Simulators.csproj +++ b/src/Simulation/Simulators/Microsoft.Quantum.Simulators.csproj @@ -1,4 +1,4 @@ - + diff --git a/src/Simulation/Type1Core/Microsoft.Quantum.Type1.Core.csproj b/src/Simulation/Type1Core/Microsoft.Quantum.Type1.Core.csproj index f75c9ba8145..7df28e51b76 100644 --- a/src/Simulation/Type1Core/Microsoft.Quantum.Type1.Core.csproj +++ b/src/Simulation/Type1Core/Microsoft.Quantum.Type1.Core.csproj @@ -1,4 +1,4 @@ - + diff --git a/src/Simulation/Type2Core/Microsoft.Quantum.Type2.Core.csproj b/src/Simulation/Type2Core/Microsoft.Quantum.Type2.Core.csproj index 804ad9d7054..524b9c41c1e 100644 --- a/src/Simulation/Type2Core/Microsoft.Quantum.Type2.Core.csproj +++ b/src/Simulation/Type2Core/Microsoft.Quantum.Type2.Core.csproj @@ -1,4 +1,4 @@ - + diff --git a/src/Simulation/Type3Core/Microsoft.Quantum.Type3.Core.csproj b/src/Simulation/Type3Core/Microsoft.Quantum.Type3.Core.csproj index bfd3eee533e..8ad18d2562c 100644 --- a/src/Simulation/Type3Core/Microsoft.Quantum.Type3.Core.csproj +++ b/src/Simulation/Type3Core/Microsoft.Quantum.Type3.Core.csproj @@ -1,4 +1,4 @@ - + From d430671870c4ddbda04c8cbe2580a8ad8fc50eff Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Thu, 18 Mar 2021 11:36:47 -0700 Subject: [PATCH 11/14] Fixing test script. --- src/QirRuntime/test-qir-runtime.ps1 | 1 + 1 file changed, 1 insertion(+) diff --git a/src/QirRuntime/test-qir-runtime.ps1 b/src/QirRuntime/test-qir-runtime.ps1 index ecf02e60823..5a96cbb7843 100644 --- a/src/QirRuntime/test-qir-runtime.ps1 +++ b/src/QirRuntime/test-qir-runtime.ps1 @@ -1,6 +1,7 @@ # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. +& (Join-Path $PSScriptRoot .. .. build set-env.ps1) $all_ok = $true Write-Host "##[info]Test QIR Runtime" From 2d5e51e83fad03c84b28c4bd065d54abc95e7397 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Thu, 18 Mar 2021 11:54:16 -0700 Subject: [PATCH 12/14] Removed auto-gen files --- .../qir/qir-standalone-input-reference.ll | 89 - .../qsharp/qir/qir-test-simulator.ll | 1367 ----------- .../QIR-dynamic/qsharp/qir/qir-test-random.ll | 142 -- .../test/QIR-tracer/qsharp/qir/tracer-qir.ll | 2080 ----------------- 4 files changed, 3678 deletions(-) delete mode 100644 src/QirRuntime/samples/StandaloneInputReference/qsharp/qir/qir-standalone-input-reference.ll delete mode 100644 src/QirRuntime/test/FullstateSimulator/qsharp/qir/qir-test-simulator.ll delete mode 100644 src/QirRuntime/test/QIR-dynamic/qsharp/qir/qir-test-random.ll delete mode 100644 src/QirRuntime/test/QIR-tracer/qsharp/qir/tracer-qir.ll diff --git a/src/QirRuntime/samples/StandaloneInputReference/qsharp/qir/qir-standalone-input-reference.ll b/src/QirRuntime/samples/StandaloneInputReference/qsharp/qir/qir-standalone-input-reference.ll deleted file mode 100644 index 29f506d0d40..00000000000 --- a/src/QirRuntime/samples/StandaloneInputReference/qsharp/qir/qir-standalone-input-reference.ll +++ /dev/null @@ -1,89 +0,0 @@ - -%Range = type { i64, i64, i64 } -%Result = type opaque -%String = type opaque - -@PauliI = constant i2 0 -@PauliX = constant i2 1 -@PauliY = constant i2 -1 -@PauliZ = constant i2 -2 -@EmptyRange = internal constant %Range { i64 0, i64 1, i64 -1 } -@0 = internal constant [26 x i8] c"Exercise Supported Inputs\00" -@1 = internal constant [11 x i8] c"intValue: \00" -@2 = internal constant [14 x i8] c"doubleValue: \00" -@3 = internal constant [14 x i8] c"resultValue: \00" -@4 = internal constant [14 x i8] c"stringValue: \00" - -define i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs__body(i64 %intValue, double %doubleValue, %Result* %resultValue, %String* %stringValue) { -entry: - %msg = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @0, i32 0, i32 0)) - call void @__quantum__qis__message__body(%String* %msg) - call void @__quantum__rt__string_update_reference_count(%String* %msg, i32 -1) - %0 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @1, i32 0, i32 0)) - %1 = call %String* @__quantum__rt__int_to_string(i64 %intValue) - %msg__1 = call %String* @__quantum__rt__string_concatenate(%String* %0, %String* %1) - call void @__quantum__rt__string_update_reference_count(%String* %0, i32 -1) - call void @__quantum__rt__string_update_reference_count(%String* %1, i32 -1) - call void @__quantum__qis__message__body(%String* %msg__1) - call void @__quantum__rt__string_update_reference_count(%String* %msg__1, i32 -1) - %2 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @2, i32 0, i32 0)) - %3 = call %String* @__quantum__rt__double_to_string(double %doubleValue) - %msg__2 = call %String* @__quantum__rt__string_concatenate(%String* %2, %String* %3) - call void @__quantum__rt__string_update_reference_count(%String* %2, i32 -1) - call void @__quantum__rt__string_update_reference_count(%String* %3, i32 -1) - call void @__quantum__qis__message__body(%String* %msg__2) - call void @__quantum__rt__string_update_reference_count(%String* %msg__2, i32 -1) - %4 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @3, i32 0, i32 0)) - %5 = call %String* @__quantum__rt__result_to_string(%Result* %resultValue) - %msg__3 = call %String* @__quantum__rt__string_concatenate(%String* %4, %String* %5) - call void @__quantum__rt__string_update_reference_count(%String* %4, i32 -1) - call void @__quantum__rt__string_update_reference_count(%String* %5, i32 -1) - call void @__quantum__qis__message__body(%String* %msg__3) - call void @__quantum__rt__string_update_reference_count(%String* %msg__3, i32 -1) - %6 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @4, i32 0, i32 0)) - call void @__quantum__rt__string_update_reference_count(%String* %stringValue, i32 1) - %msg__4 = call %String* @__quantum__rt__string_concatenate(%String* %6, %String* %stringValue) - call void @__quantum__rt__string_update_reference_count(%String* %6, i32 -1) - call void @__quantum__rt__string_update_reference_count(%String* %stringValue, i32 -1) - call void @__quantum__qis__message__body(%String* %msg__4) - call void @__quantum__rt__string_update_reference_count(%String* %msg__4, i32 -1) - ret i64 0 -} - -declare %String* @__quantum__rt__string_create(i8*) - -declare void @__quantum__qis__message__body(%String*) - -declare void @__quantum__rt__string_update_reference_count(%String*, i32) - -declare %String* @__quantum__rt__int_to_string(i64) - -declare %String* @__quantum__rt__string_concatenate(%String*, %String*) - -declare %String* @__quantum__rt__double_to_string(double) - -declare %String* @__quantum__rt__result_to_string(%Result*) - -define void @Microsoft__Quantum__Intrinsic__Message__body(%String* %msg) { -entry: - call void @__quantum__qis__message__body(%String* %msg) - ret void -} - -define i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs(i64 %intValue, double %doubleValue, i8 %resultValue, i8* %stringValue) #0 { -entry: - %0 = icmp eq i8 %resultValue, 0 - %1 = call %Result* @__quantum__rt__result_get_zero() - %2 = call %Result* @__quantum__rt__result_get_one() - %3 = select i1 %0, %Result* %1, %Result* %2 - %4 = call %String* @__quantum__rt__string_create(i8* %stringValue) - %5 = call i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs__body(i64 %intValue, double %doubleValue, %Result* %3, %String* %4) - call void @__quantum__rt__string_update_reference_count(%String* %4, i32 -1) - ret i64 %5 -} - -declare %Result* @__quantum__rt__result_get_zero() - -declare %Result* @__quantum__rt__result_get_one() - -attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/test/FullstateSimulator/qsharp/qir/qir-test-simulator.ll b/src/QirRuntime/test/FullstateSimulator/qsharp/qir/qir-test-simulator.ll deleted file mode 100644 index 4b4b24c51a8..00000000000 --- a/src/QirRuntime/test/FullstateSimulator/qsharp/qir/qir-test-simulator.ll +++ /dev/null @@ -1,1367 +0,0 @@ - -%Range = type { i64, i64, i64 } -%Tuple = type opaque -%Callable = type opaque -%Qubit = type opaque -%Array = type opaque -%Result = type opaque - -@PauliI = constant i2 0 -@PauliX = constant i2 1 -@PauliY = constant i2 -1 -@PauliZ = constant i2 -2 -@EmptyRange = internal constant %Range { i64 0, i64 1, i64 -1 } -@Microsoft__Quantum__Intrinsic__X = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__Y = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__Z = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__H = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__S = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__T = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__R = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__ctladj__wrapper] -@PartialApplication__1 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__ctladj__wrapper] -@MemoryManagement__1 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__1__RefCount, void (%Tuple*, i32)* @MemoryManagement__1__AliasCount] - -@Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS = alias i64 (), i64 ()* @Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS__body - -define i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %op) { -entry: - call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 1) - %res = alloca i64, align 8 - store i64 0, i64* %res, align 4 - %target = call %Qubit* @__quantum__rt__qubit_allocate() - %ctls = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) - %1 = bitcast %Tuple* %0 to { %Qubit* }* - %2 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %1, i32 0, i32 0 - store %Qubit* %target, %Qubit** %2, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %op, %Tuple* %0, %Tuple* null) - %3 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 1) - call void @__quantum__rt__callable_make_adjoint(%Callable* %3) - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { %Qubit* }* - %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 - store %Qubit* %target, %Qubit** %6, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %3, %Tuple* %4, %Tuple* null) - %7 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %target) - %8 = call %Result* @__quantum__rt__result_get_zero() - %9 = call i1 @__quantum__rt__result_equal(%Result* %7, %Result* %8) - %10 = xor i1 %9, true - br i1 %10, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - store i64 1, i64* %res, align 4 - br label %continue__1 - -else__1: ; preds = %entry - %11 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %12 = bitcast i8* %11 to %Qubit** - %qubit = load %Qubit*, %Qubit** %12, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit) - %13 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) - %14 = bitcast i8* %13 to %Qubit** - %qubit__1 = load %Qubit*, %Qubit** %14, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__1) - %15 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 1) - call void @__quantum__rt__callable_make_controlled(%Callable* %15) - %16 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) - %17 = bitcast %Tuple* %16 to { %Array*, %Qubit* }* - %18 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %17, i32 0, i32 0 - %19 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %17, i32 0, i32 1 - store %Array* %ctls, %Array** %18, align 8 - store %Qubit* %target, %Qubit** %19, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %15, %Tuple* %16, %Tuple* null) - %20 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %20, i32 1) - call void @__quantum__rt__callable_make_controlled(%Callable* %20) - call void @__quantum__rt__callable_make_adjoint(%Callable* %20) - %21 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) - %22 = bitcast %Tuple* %21 to { %Array*, %Qubit* }* - %23 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %22, i32 0, i32 0 - %24 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %22, i32 0, i32 1 - store %Array* %ctls, %Array** %23, align 8 - store %Qubit* %target, %Qubit** %24, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %20, %Tuple* %21, %Tuple* null) - %25 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %target) - %26 = call %Result* @__quantum__rt__result_get_zero() - %27 = call i1 @__quantum__rt__result_equal(%Result* %25, %Result* %26) - %28 = xor i1 %27, true - br i1 %28, label %then0__2, label %continue__2 - -then0__2: ; preds = %else__1 - store i64 2, i64* %res, align 4 - br label %continue__2 - -continue__2: ; preds = %then0__2, %else__1 - %29 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %30 = bitcast i8* %29 to %Qubit** - %qubit__2 = load %Qubit*, %Qubit** %30, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__2) - %31 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) - %32 = bitcast i8* %31 to %Qubit** - %qubit__3 = load %Qubit*, %Qubit** %32, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__3) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %16, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %20, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %20, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %21, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %25, i32 -1) - br label %continue__1 - -continue__1: ; preds = %continue__2, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %7, i32 -1) - call void @__quantum__rt__qubit_release(%Qubit* %target) - call void @__quantum__rt__qubit_release_array(%Array* %ctls) - %33 = load i64, i64* %res, align 4 - call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 -1) - ret i64 %33 -} - -declare void @__quantum__rt__capture_update_alias_count(%Callable*, i32) - -declare void @__quantum__rt__callable_update_alias_count(%Callable*, i32) - -declare %Qubit* @__quantum__rt__qubit_allocate() - -declare %Array* @__quantum__rt__qubit_allocate_array(i64) - -declare void @__quantum__rt__array_update_alias_count(%Array*, i32) - -declare void @__quantum__rt__callable_invoke(%Callable*, %Tuple*, %Tuple*) - -declare %Tuple* @__quantum__rt__tuple_create(i64) - -declare %Callable* @__quantum__rt__callable_copy(%Callable*, i1) - -declare void @__quantum__rt__capture_update_reference_count(%Callable*, i32) - -declare void @__quantum__rt__callable_make_adjoint(%Callable*) - -define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qubit) { -entry: - %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) - %1 = bitcast i8* %0 to i2* - %2 = load i2, i2* @PauliZ, align 1 - store i2 %2, i2* %1, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) - %qubits = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %3 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) - %4 = bitcast i8* %3 to %Qubit** - store %Qubit* %qubit, %Qubit** %4, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %5 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qubits, i32 -1) - ret %Result* %5 -} - -declare %Result* @__quantum__rt__result_get_zero() - -declare i1 @__quantum__rt__result_equal(%Result*, %Result*) - -declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) - -declare void @__quantum__qis__h__body(%Qubit*) - -declare void @__quantum__rt__callable_make_controlled(%Callable*) - -declare void @__quantum__rt__callable_update_reference_count(%Callable*, i32) - -declare void @__quantum__rt__tuple_update_reference_count(%Tuple*, i32) - -declare void @__quantum__rt__result_update_reference_count(%Result*, i32) - -declare void @__quantum__rt__qubit_release(%Qubit*) - -declare void @__quantum__rt__qubit_release_array(%Array*) - -define i64 @Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS__body() #0 { -entry: - %res = alloca i64, align 8 - store i64 0, i64* %res, align 4 - %0 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__X, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %1 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %0) - store i64 %1, i64* %res, align 4 - %2 = icmp ne i64 %1, 0 - br i1 %2, label %then0__1, label %continue__1 - -then0__1: ; preds = %entry - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - ret i64 %1 - -continue__1: ; preds = %entry - %3 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Y, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %4 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %3) - store i64 %4, i64* %res, align 4 - %5 = icmp ne i64 %4, 0 - br i1 %5, label %then0__2, label %continue__2 - -then0__2: ; preds = %continue__1 - %6 = add i64 10, %4 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - ret i64 %6 - -continue__2: ; preds = %continue__1 - %7 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Z, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %8 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %7) - store i64 %8, i64* %res, align 4 - %9 = icmp ne i64 %8, 0 - br i1 %9, label %then0__3, label %continue__3 - -then0__3: ; preds = %continue__2 - %10 = add i64 20, %8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - ret i64 %10 - -continue__3: ; preds = %continue__2 - %11 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__H, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %12 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %11) - store i64 %12, i64* %res, align 4 - %13 = icmp ne i64 %12, 0 - br i1 %13, label %then0__4, label %continue__4 - -then0__4: ; preds = %continue__3 - %14 = add i64 30, %12 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - ret i64 %14 - -continue__4: ; preds = %continue__3 - %15 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__S, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %16 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %15) - store i64 %16, i64* %res, align 4 - %17 = icmp ne i64 %16, 0 - br i1 %17, label %then0__5, label %continue__5 - -then0__5: ; preds = %continue__4 - %18 = add i64 40, %16 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - ret i64 %18 - -continue__5: ; preds = %continue__4 - %19 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__T, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %20 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %19) - store i64 %20, i64* %res, align 4 - %21 = icmp ne i64 %20, 0 - br i1 %21, label %then0__6, label %continue__6 - -then0__6: ; preds = %continue__5 - %22 = add i64 50, %20 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) - ret i64 %22 - -continue__6: ; preds = %continue__5 - %23 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Callable*, i2, double }* getelementptr ({ %Callable*, i2, double }, { %Callable*, i2, double }* null, i32 1) to i64)) - %24 = bitcast %Tuple* %23 to { %Callable*, i2, double }* - %25 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 0 - %26 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 1 - %27 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 2 - %28 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__R, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %29 = load i2, i2* @PauliX, align 1 - store %Callable* %28, %Callable** %25, align 8 - store i2 %29, i2* %26, align 1 - store double 4.200000e-01, double* %27, align 8 - %30 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__1, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %23) - %31 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %30) - store i64 %31, i64* %res, align 4 - %32 = icmp ne i64 %31, 0 - br i1 %32, label %then0__7, label %continue__7 - -then0__7: ; preds = %continue__6 - %33 = add i64 60, %31 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) - ret i64 %33 - -continue__7: ; preds = %continue__6 - %targets = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) - %ctls = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %paulis = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %34 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %35 = bitcast i8* %34 to i2* - %36 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %37 = bitcast i8* %36 to i2* - %38 = load i2, i2* @PauliX, align 1 - %39 = load i2, i2* @PauliY, align 1 - store i2 %38, i2* %35, align 1 - store i2 %39, i2* %37, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) - call void @__quantum__qis__exp__body(%Array* %paulis, double 4.200000e-01, %Array* %targets) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis, i32 -1) - %paulis__1 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__1, i64 0) - %41 = bitcast i8* %40 to i2* - %42 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__1, i64 1) - %43 = bitcast i8* %42 to i2* - %44 = load i2, i2* @PauliX, align 1 - %45 = load i2, i2* @PauliY, align 1 - store i2 %44, i2* %41, align 1 - store i2 %45, i2* %43, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__1, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) - call void @__quantum__qis__exp__adj(%Array* %paulis__1, double 4.200000e-01, %Array* %targets) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__1, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis__1, i32 -1) - %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %targets, i64 0) - %47 = bitcast i8* %46 to %Qubit** - %48 = load %Qubit*, %Qubit** %47, align 8 - %49 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %48) - %50 = call %Result* @__quantum__rt__result_get_zero() - %51 = call i1 @__quantum__rt__result_equal(%Result* %49, %Result* %50) - %52 = xor i1 %51, true - br i1 %52, label %then0__8, label %continue__8 - -then0__8: ; preds = %continue__7 - store i64 1, i64* %res, align 4 - br label %continue__8 - -continue__8: ; preds = %then0__8, %continue__7 - %53 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %54 = bitcast i8* %53 to %Qubit** - %qubit = load %Qubit*, %Qubit** %54, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit) - %55 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) - %56 = bitcast i8* %55 to %Qubit** - %qubit__1 = load %Qubit*, %Qubit** %56, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %paulis__2 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %57 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__2, i64 0) - %58 = bitcast i8* %57 to i2* - %59 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__2, i64 1) - %60 = bitcast i8* %59 to i2* - %61 = load i2, i2* @PauliX, align 1 - %62 = load i2, i2* @PauliY, align 1 - store i2 %61, i2* %58, align 1 - store i2 %62, i2* %60, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__2, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) - %63 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %64 = bitcast %Tuple* %63 to { %Array*, double, %Array* }* - %65 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 0 - %66 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 1 - %67 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 2 - store %Array* %paulis__2, %Array** %65, align 8 - store double 4.200000e-01, double* %66, align 8 - store %Array* %targets, %Array** %67, align 8 - call void @__quantum__qis__exp__ctl(%Array* %ctls, { %Array*, double, %Array* }* %64) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__2, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis__2, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %63, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %paulis__3 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %68 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__3, i64 0) - %69 = bitcast i8* %68 to i2* - %70 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__3, i64 1) - %71 = bitcast i8* %70 to i2* - %72 = load i2, i2* @PauliX, align 1 - %73 = load i2, i2* @PauliY, align 1 - store i2 %72, i2* %69, align 1 - store i2 %73, i2* %71, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__3, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) - %74 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %75 = bitcast %Tuple* %74 to { %Array*, double, %Array* }* - %76 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 0 - %77 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 1 - %78 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 2 - store %Array* %paulis__3, %Array** %76, align 8 - store double 4.200000e-01, double* %77, align 8 - store %Array* %targets, %Array** %78, align 8 - call void @__quantum__qis__exp__ctladj(%Array* %ctls, { %Array*, double, %Array* }* %75) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__3, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis__3, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %74, i32 -1) - %79 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %80 = bitcast i8* %79 to %Qubit** - %qubit__2 = load %Qubit*, %Qubit** %80, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__2) - %81 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) - %82 = bitcast i8* %81 to %Qubit** - %qubit__3 = load %Qubit*, %Qubit** %82, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__3) - %83 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %targets, i64 0) - %84 = bitcast i8* %83 to %Qubit** - %85 = load %Qubit*, %Qubit** %84, align 8 - %86 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %85) - %87 = call %Result* @__quantum__rt__result_get_zero() - %88 = call i1 @__quantum__rt__result_equal(%Result* %86, %Result* %87) - %89 = xor i1 %88, true - br i1 %89, label %then0__9, label %continue__9 - -then0__9: ; preds = %continue__8 - store i64 2, i64* %res, align 4 - br label %continue__9 - -continue__9: ; preds = %then0__9, %continue__8 - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %49, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %86, i32 -1) - call void @__quantum__rt__qubit_release_array(%Array* %targets) - call void @__quantum__rt__qubit_release_array(%Array* %ctls) - %90 = load i64, i64* %res, align 4 - %91 = icmp ne i64 %90, 0 - br i1 %91, label %then0__10, label %continue__10 - -then0__10: ; preds = %continue__9 - %92 = add i64 70, %90 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) - ret i64 %92 - -continue__10: ; preds = %continue__9 - %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 3) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) - %93 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %94 = bitcast i8* %93 to %Qubit** - %qubit__4 = load %Qubit*, %Qubit** %94, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__4) - %95 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %96 = bitcast i8* %95 to %Qubit** - %qubit__5 = load %Qubit*, %Qubit** %96, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__5) - %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 3) - %97 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) - %98 = bitcast i8* %97 to i2* - %99 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 1) - %100 = bitcast i8* %99 to i2* - %101 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 2) - %102 = bitcast i8* %101 to i2* - %103 = load i2, i2* @PauliX, align 1 - %104 = load i2, i2* @PauliZ, align 1 - %105 = load i2, i2* @PauliX, align 1 - store i2 %103, i2* %98, align 1 - store i2 %104, i2* %100, align 1 - store i2 %105, i2* %102, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) - %106 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qs) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) - %107 = call %Result* @__quantum__rt__result_get_zero() - %108 = call i1 @__quantum__rt__result_equal(%Result* %106, %Result* %107) - %109 = xor i1 %108, true - br i1 %109, label %then0__11, label %continue__11 - -then0__11: ; preds = %continue__10 - store i64 80, i64* %res, align 4 - br label %continue__11 - -continue__11: ; preds = %then0__11, %continue__10 - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %106, i32 -1) - call void @__quantum__rt__qubit_release_array(%Array* %qs) - %110 = load i64, i64* %res, align 4 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) - ret i64 %110 -} - -define void @Microsoft__Quantum__Intrinsic__X__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -declare %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]*, [2 x void (%Tuple*, i32)*]*, %Tuple*) - -define void @Microsoft__Quantum__Intrinsic__Y__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__T__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__T__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__R__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { i2, double, %Qubit* }* - %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 - %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 - %4 = load i2, i2* %1, align 1 - %5 = load double, double* %2, align 8 - %6 = load %Qubit*, %Qubit** %3, align 8 - call void @Microsoft__Quantum__Intrinsic__R__body(i2 %4, double %5, %Qubit* %6) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__R__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { i2, double, %Qubit* }* - %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 - %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 - %4 = load i2, i2* %1, align 1 - %5 = load double, double* %2, align 8 - %6 = load %Qubit*, %Qubit** %3, align 8 - call void @Microsoft__Quantum__Intrinsic__R__adj(i2 %4, double %5, %Qubit* %6) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__R__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, { i2, double, %Qubit* }* }* - %1 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load { i2, double, %Qubit* }*, { i2, double, %Qubit* }** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__R__ctl(%Array* %3, { i2, double, %Qubit* }* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__R__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, { i2, double, %Qubit* }* }* - %1 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load { i2, double, %Qubit* }*, { i2, double, %Qubit* }** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__R__ctladj(%Array* %3, { i2, double, %Qubit* }* %4) - ret void -} - -define void @Lifted__PartialApplication__1__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 1 - %2 = load i2, i2* %1, align 1 - %3 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 2 - %4 = load double, double* %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 - %7 = load %Qubit*, %Qubit** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %9 = bitcast %Tuple* %8 to { i2, double, %Qubit* }* - %10 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 2 - store i2 %2, i2* %10, align 1 - store double %4, double* %11, align 8 - store %Qubit* %7, %Qubit** %12, align 8 - %13 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - ret void -} - -define void @Lifted__PartialApplication__1__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 1 - %2 = load i2, i2* %1, align 1 - %3 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 2 - %4 = load double, double* %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 - %7 = load %Qubit*, %Qubit** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %9 = bitcast %Tuple* %8 to { i2, double, %Qubit* }* - %10 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 2 - store i2 %2, i2* %10, align 1 - store double %4, double* %11, align 8 - store %Qubit* %7, %Qubit** %12, align 8 - %13 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - %15 = call %Callable* @__quantum__rt__callable_copy(%Callable* %14, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 1) - call void @__quantum__rt__callable_make_adjoint(%Callable* %15) - call void @__quantum__rt__callable_invoke(%Callable* %15, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - ret void -} - -define void @Lifted__PartialApplication__1__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - %5 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %6 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 1 - %7 = load i2, i2* %6, align 1 - %8 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 2 - %9 = load double, double* %8, align 8 - %10 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %11 = bitcast %Tuple* %10 to { i2, double, %Qubit* }* - %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 0 - %13 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 1 - %14 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 2 - store i2 %7, i2* %12, align 1 - store double %9, double* %13, align 8 - store %Qubit* %4, %Qubit** %14, align 8 - %15 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) - %16 = bitcast %Tuple* %15 to { %Array*, { i2, double, %Qubit* }* }* - %17 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 0 - %18 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 1 - store %Array* %3, %Array** %17, align 8 - store { i2, double, %Qubit* }* %11, { i2, double, %Qubit* }** %18, align 8 - %19 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 0 - %20 = load %Callable*, %Callable** %19, align 8 - %21 = call %Callable* @__quantum__rt__callable_copy(%Callable* %20, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 1) - call void @__quantum__rt__callable_make_controlled(%Callable* %21) - call void @__quantum__rt__callable_invoke(%Callable* %21, %Tuple* %15, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %10, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %21, i32 -1) - ret void -} - -define void @Lifted__PartialApplication__1__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - %5 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %6 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 1 - %7 = load i2, i2* %6, align 1 - %8 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 2 - %9 = load double, double* %8, align 8 - %10 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %11 = bitcast %Tuple* %10 to { i2, double, %Qubit* }* - %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 0 - %13 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 1 - %14 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 2 - store i2 %7, i2* %12, align 1 - store double %9, double* %13, align 8 - store %Qubit* %4, %Qubit** %14, align 8 - %15 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) - %16 = bitcast %Tuple* %15 to { %Array*, { i2, double, %Qubit* }* }* - %17 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 0 - %18 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 1 - store %Array* %3, %Array** %17, align 8 - store { i2, double, %Qubit* }* %11, { i2, double, %Qubit* }** %18, align 8 - %19 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 0 - %20 = load %Callable*, %Callable** %19, align 8 - %21 = call %Callable* @__quantum__rt__callable_copy(%Callable* %20, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 1) - call void @__quantum__rt__callable_make_adjoint(%Callable* %21) - call void @__quantum__rt__callable_make_controlled(%Callable* %21) - call void @__quantum__rt__callable_invoke(%Callable* %21, %Tuple* %15, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %10, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %21, i32 -1) - ret void -} - -define void @MemoryManagement__1__RefCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -define void @MemoryManagement__1__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -declare %Array* @__quantum__rt__array_create_1d(i32, i64) - -declare void @__quantum__qis__exp__body(%Array*, double, %Array*) - -declare void @__quantum__rt__array_update_reference_count(%Array*, i32) - -declare void @__quantum__qis__exp__adj(%Array*, double, %Array*) - -declare void @__quantum__qis__exp__ctl(%Array*, { %Array*, double, %Array* }*) - -declare void @__quantum__qis__exp__ctladj(%Array*, { %Array*, double, %Array* }*) - -declare %Result* @__quantum__qis__measure__body(%Array*, %Array*) - -define void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__s__body(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__s__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__s__adj(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__s__adj(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__s__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__s__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__s__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__s__ctladj(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Exp__body(%Array* %paulis, double %theta, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - call void @__quantum__qis__exp__body(%Array* %paulis, double %theta, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Exp__adj(%Array* %paulis, double %theta, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - call void @__quantum__qis__exp__adj(%Array* %paulis, double %theta, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Exp__ctl(%Array* %__controlQubits__, { %Array*, double, %Array* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %1 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 0 - %paulis = load %Array*, %Array** %1, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - %2 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 1 - %theta = load double, double* %2, align 8 - %3 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 2 - %qubits = load %Array*, %Array** %3, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { %Array*, double, %Array* }* - %6 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 0 - %7 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 1 - %8 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 2 - store %Array* %paulis, %Array** %6, align 8 - store double %theta, double* %7, align 8 - store %Array* %qubits, %Array** %8, align 8 - call void @__quantum__qis__exp__ctl(%Array* %__controlQubits__, { %Array*, double, %Array* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Exp__ctladj(%Array* %__controlQubits__, { %Array*, double, %Array* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %1 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 0 - %paulis = load %Array*, %Array** %1, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - %2 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 1 - %theta = load double, double* %2, align 8 - %3 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 2 - %qubits = load %Array*, %Array** %3, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { %Array*, double, %Array* }* - %6 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 0 - %7 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 1 - %8 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 2 - store %Array* %paulis, %Array** %6, align 8 - store double %theta, double* %7, align 8 - store %Array* %qubits, %Array** %8, align 8 - call void @__quantum__qis__exp__ctladj(%Array* %__controlQubits__, { %Array*, double, %Array* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__t__body(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__t__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__T__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__t__adj(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__t__adj(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__t__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__t__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__t__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__t__ctladj(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__h__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__x__body(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__x__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__x__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__x__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__x__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__x__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__R__body(i2 %pauli, double %theta, %Qubit* %qubit) { -entry: - call void @__quantum__qis__r__body(i2 %pauli, double %theta, %Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__r__body(i2, double, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__R__adj(i2 %pauli, double %theta, %Qubit* %qubit) { -entry: - call void @__quantum__qis__r__adj(i2 %pauli, double %theta, %Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__r__adj(i2, double, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__R__ctl(%Array* %__controlQubits__, { i2, double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 - %pauli = load i2, i2* %1, align 1 - %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 - %theta = load double, double* %2, align 8 - %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 - %qubit = load %Qubit*, %Qubit** %3, align 8 - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { i2, double, %Qubit* }* - %6 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 0 - %7 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 1 - %8 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 2 - store i2 %pauli, i2* %6, align 1 - store double %theta, double* %7, align 8 - store %Qubit* %qubit, %Qubit** %8, align 8 - call void @__quantum__qis__r__ctl(%Array* %__controlQubits__, { i2, double, %Qubit* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) - ret void -} - -declare void @__quantum__qis__r__ctl(%Array*, { i2, double, %Qubit* }*) - -define void @Microsoft__Quantum__Intrinsic__R__ctladj(%Array* %__controlQubits__, { i2, double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 - %pauli = load i2, i2* %1, align 1 - %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 - %theta = load double, double* %2, align 8 - %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 - %qubit = load %Qubit*, %Qubit** %3, align 8 - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { i2, double, %Qubit* }* - %6 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 0 - %7 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 1 - %8 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 2 - store i2 %pauli, i2* %6, align 1 - store double %theta, double* %7, align 8 - store %Qubit* %qubit, %Qubit** %8, align 8 - call void @__quantum__qis__r__ctladj(%Array* %__controlQubits__, { i2, double, %Qubit* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) - ret void -} - -declare void @__quantum__qis__r__ctladj(%Array*, { i2, double, %Qubit* }*) - -define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %bases, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -define void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__z__body(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__z__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__z__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__z__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__y__body(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__y__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__y__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__y__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__rt__tuple_update_alias_count(%Tuple*, i32) - -attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/test/QIR-dynamic/qsharp/qir/qir-test-random.ll b/src/QirRuntime/test/QIR-dynamic/qsharp/qir/qir-test-random.ll deleted file mode 100644 index 5cca945317a..00000000000 --- a/src/QirRuntime/test/QIR-dynamic/qsharp/qir/qir-test-random.ll +++ /dev/null @@ -1,142 +0,0 @@ - -%Range = type { i64, i64, i64 } -%Qubit = type opaque -%Result = type opaque -%Array = type opaque - -@PauliI = constant i2 0 -@PauliX = constant i2 1 -@PauliY = constant i2 -1 -@PauliZ = constant i2 -2 -@EmptyRange = internal constant %Range { i64 0, i64 1, i64 -1 } - -@Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator = alias i64 (), i64 ()* @Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator__body - -define i64 @Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator__body() #0 { -entry: - %randomNumber = alloca i64, align 8 - store i64 0, i64* %randomNumber, align 4 - br label %header__1 - -header__1: ; preds = %exiting__1, %entry - %i = phi i64 [ 1, %entry ], [ %8, %exiting__1 ] - %0 = icmp sle i64 %i, 64 - br i1 %0, label %body__1, label %exit__1 - -body__1: ; preds = %header__1 - %q = call %Qubit* @__quantum__rt__qubit_allocate() - call void @__quantum__qis__h__body(%Qubit* %q) - %1 = load i64, i64* %randomNumber, align 4 - %2 = shl i64 %1, 1 - store i64 %2, i64* %randomNumber, align 4 - %3 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %q) - %4 = call %Result* @__quantum__rt__result_get_one() - %5 = call i1 @__quantum__rt__result_equal(%Result* %3, %Result* %4) - br i1 %5, label %then0__1, label %continue__1 - -then0__1: ; preds = %body__1 - %6 = load i64, i64* %randomNumber, align 4 - %7 = add i64 %6, 1 - store i64 %7, i64* %randomNumber, align 4 - br label %continue__1 - -continue__1: ; preds = %then0__1, %body__1 - call void @__quantum__rt__result_update_reference_count(%Result* %3, i32 -1) - call void @__quantum__rt__qubit_release(%Qubit* %q) - br label %exiting__1 - -exiting__1: ; preds = %continue__1 - %8 = add i64 %i, 1 - br label %header__1 - -exit__1: ; preds = %header__1 - %9 = load i64, i64* %randomNumber, align 4 - ret i64 %9 -} - -declare %Qubit* @__quantum__rt__qubit_allocate() - -declare %Array* @__quantum__rt__qubit_allocate_array(i64) - -declare void @__quantum__qis__h__body(%Qubit*) - -define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qubit) { -entry: - %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) - %1 = bitcast i8* %0 to i2* - %2 = load i2, i2* @PauliZ, align 1 - store i2 %2, i2* %1, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) - %qubits = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %3 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) - %4 = bitcast i8* %3 to %Qubit** - store %Qubit* %qubit, %Qubit** %4, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %5 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qubits, i32 -1) - ret %Result* %5 -} - -declare %Result* @__quantum__rt__result_get_one() - -declare i1 @__quantum__rt__result_equal(%Result*, %Result*) - -declare void @__quantum__rt__result_update_reference_count(%Result*, i32) - -declare void @__quantum__rt__qubit_release(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__rt__array_update_alias_count(%Array*, i32) - -declare void @__quantum__qis__h__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %bases, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -declare %Result* @__quantum__qis__measure__body(%Array*, %Array*) - -declare %Array* @__quantum__rt__array_create_1d(i32, i64) - -declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) - -declare void @__quantum__rt__array_update_reference_count(%Array*, i32) - -attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/test/QIR-tracer/qsharp/qir/tracer-qir.ll b/src/QirRuntime/test/QIR-tracer/qsharp/qir/tracer-qir.ll deleted file mode 100644 index 0bf147d470f..00000000000 --- a/src/QirRuntime/test/QIR-tracer/qsharp/qir/tracer-qir.ll +++ /dev/null @@ -1,2080 +0,0 @@ - -%Range = type { i64, i64, i64 } -%Tuple = type opaque -%Result = type opaque -%Qubit = type opaque -%Array = type opaque -%Callable = type opaque -%String = type opaque - -@PauliI = constant i2 0 -@PauliX = constant i2 1 -@PauliY = constant i2 -1 -@PauliZ = constant i2 -2 -@EmptyRange = internal constant %Range { i64 0, i64 1, i64 -1 } -@Microsoft__Quantum__Testing__Tracer__Delay = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Testing__Tracer__Delay__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@Microsoft__Quantum__Intrinsic__X = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper] -@PartialApplication__1 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@MemoryManagement__1 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__1__RefCount, void (%Tuple*, i32)* @MemoryManagement__1__AliasCount] -@Microsoft__Quantum__Intrinsic__Y = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper] -@PartialApplication__2 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__2__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@Microsoft__Quantum__Intrinsic__Z = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper] -@PartialApplication__3 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__3__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@Microsoft__Quantum__Intrinsic__S = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper] -@PartialApplication__4 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__4__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@MemoryManagement__2 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__2__RefCount, void (%Tuple*, i32)* @MemoryManagement__2__AliasCount] - -define %Result* @Microsoft__Quantum__Instructions__Mx__body(%Qubit* %qb) { -entry: - %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb) - ret %Result* %0 -} - -declare %Result* @__quantum__qis__single_qubit_measure(i64, i64, %Qubit*) - -define %Result* @Microsoft__Quantum__Instructions__Mxx__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -declare void @__quantum__rt__array_update_alias_count(%Array*, i32) - -declare %Result* @__quantum__qis__joint_measure(i64, i64, %Array*) - -define %Result* @Microsoft__Quantum__Instructions__Mxz__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mz__body(%Qubit* %qb) { -entry: - %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mzx__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mzz__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -define void @Microsoft__Quantum__Instructions__Sx__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) - ret void -} - -declare void @__quantum__qis__single_qubit_op(i64, i64, %Qubit*) - -define void @Microsoft__Quantum__Instructions__Sx__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sx__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -declare void @__quantum__qis__single_qubit_op_ctl(i64, i64, %Array*, %Qubit*) - -define void @Microsoft__Quantum__Instructions__Sx__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__ApplyConditionallyIntrinsic__body(%Array* %measurementResults, %Array* %resultsValues, %Callable* %onEqualOp, %Callable* %onNonEqualOp) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i32 1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onEqualOp, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i32 1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onNonEqualOp, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i32 1) - call void @__quantum__qis__apply_conditionally(%Array* %measurementResults, %Array* %resultsValues, %Callable* %onEqualOp, %Callable* %onNonEqualOp) - call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i32 -1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onEqualOp, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i32 -1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onNonEqualOp, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i32 -1) - ret void -} - -declare void @__quantum__rt__capture_update_alias_count(%Callable*, i32) - -declare void @__quantum__rt__callable_update_alias_count(%Callable*, i32) - -declare void @__quantum__qis__apply_conditionally(%Array*, %Array*, %Callable*, %Callable*) - -define void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %measurementResult, %Callable* %onResultZeroOp, %Callable* %onResultOneOp) { -entry: - call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultZeroOp, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i32 1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultOneOp, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i32 1) - %0 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %1 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %0, i64 0) - %2 = bitcast i8* %1 to %Result** - store %Result* %measurementResult, %Result** %2, align 8 - %3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 0) - %5 = bitcast i8* %4 to %Result** - %6 = call %Result* @__quantum__rt__result_get_zero() - store %Result* %6, %Result** %5, align 8 - call void @__quantum__qis__apply_conditionally(%Array* %0, %Array* %3, %Callable* %onResultZeroOp, %Callable* %onResultOneOp) - call void @__quantum__rt__result_update_reference_count(%Result* %measurementResult, i32 1) - call void @__quantum__rt__result_update_reference_count(%Result* %6, i32 1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultZeroOp, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i32 -1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultOneOp, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i32 -1) - br label %header__1 - -header__1: ; preds = %exiting__1, %entry - %7 = phi i64 [ 0, %entry ], [ %12, %exiting__1 ] - %8 = icmp sle i64 %7, 0 - br i1 %8, label %body__1, label %exit__1 - -body__1: ; preds = %header__1 - %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %0, i64 %7) - %10 = bitcast i8* %9 to %Result** - %11 = load %Result*, %Result** %10, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %11, i32 -1) - br label %exiting__1 - -exiting__1: ; preds = %body__1 - %12 = add i64 %7, 1 - br label %header__1 - -exit__1: ; preds = %header__1 - call void @__quantum__rt__array_update_reference_count(%Array* %0, i32 -1) - br label %header__2 - -header__2: ; preds = %exiting__2, %exit__1 - %13 = phi i64 [ 0, %exit__1 ], [ %18, %exiting__2 ] - %14 = icmp sle i64 %13, 0 - br i1 %14, label %body__2, label %exit__2 - -body__2: ; preds = %header__2 - %15 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 %13) - %16 = bitcast i8* %15 to %Result** - %17 = load %Result*, %Result** %16, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 -1) - br label %exiting__2 - -exiting__2: ; preds = %body__2 - %18 = add i64 %13, 1 - br label %header__2 - -exit__2: ; preds = %header__2 - call void @__quantum__rt__array_update_reference_count(%Array* %3, i32 -1) - ret void -} - -declare %Array* @__quantum__rt__array_create_1d(i32, i64) - -declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) - -declare %Result* @__quantum__rt__result_get_zero() - -declare void @__quantum__rt__result_update_reference_count(%Result*, i32) - -declare void @__quantum__rt__array_update_reference_count(%Array*, i32) - -define void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %control, %Qubit* %target) { -entry: - %ctls = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %1 = bitcast i8* %0 to %Qubit** - store %Qubit* %control, %Qubit** %1, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - br i1 true, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %ctls, %Qubit* %target) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %ctls, %Qubit* %target) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__CNOT__adj(%Qubit* %control, %Qubit* %target) { -entry: - call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %control, %Qubit* %target) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__CNOT__ctl(%Array* %ctls, { %Qubit*, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 0 - %control = load %Qubit*, %Qubit** %1, align 8 - %2 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 1 - %target = load %Qubit*, %Qubit** %2, align 8 - %3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 0) - %5 = bitcast i8* %4 to %Qubit** - store %Qubit* %control, %Qubit** %5, align 8 - %ctls__1 = call %Array* @__quantum__rt__array_concatenate(%Array* %ctls, %Array* %3) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 1) - %6 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls__1) - %7 = icmp eq i64 %6, 1 - br i1 %7, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %ctls__1, %Qubit* %target) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %ctls__1, %Qubit* %target) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %3, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -declare %Array* @__quantum__rt__array_concatenate(%Array*, %Array*) - -declare i64 @__quantum__rt__array_get_size_1d(%Array*) - -define void @Microsoft__Quantum__Intrinsic__CNOT__ctladj(%Array* %__controlQubits__, { %Qubit*, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %1 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 0 - %control = load %Qubit*, %Qubit** %1, align 8 - %2 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 1 - %target = load %Qubit*, %Qubit** %2, align 8 - %3 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) - %4 = bitcast %Tuple* %3 to { %Qubit*, %Qubit* }* - %5 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %4, i32 0, i32 0 - %6 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %4, i32 0, i32 1 - store %Qubit* %control, %Qubit** %5, align 8 - store %Qubit* %target, %Qubit** %6, align 8 - call void @Microsoft__Quantum__Intrinsic__CNOT__ctl(%Array* %__controlQubits__, { %Qubit*, %Qubit* }* %4) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %3, i32 -1) - ret void -} - -declare %Tuple* @__quantum__rt__tuple_create(i64) - -declare void @__quantum__rt__tuple_update_reference_count(%Tuple*, i32) - -define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qb) { -entry: - %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %paulis, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__rt__result_get_one() - %res = alloca %Result*, align 8 - store %Result* %0, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %0, i32 1) - %haveY = alloca i1, align 1 - store i1 false, i1* %haveY, align 1 - %1 = call i64 @__quantum__rt__array_get_size_1d(%Array* %paulis) - %2 = sub i64 %1, 1 - br label %header__1 - -header__1: ; preds = %exiting__1, %entry - %i = phi i64 [ 0, %entry ], [ %15, %exiting__1 ] - %3 = icmp sle i64 %i, %2 - br i1 %3, label %body__1, label %exit__1 - -body__1: ; preds = %header__1 - %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) - %5 = bitcast i8* %4 to i2* - %6 = load i2, i2* %5, align 1 - %7 = load i2, i2* @PauliY, align 1 - %8 = icmp eq i2 %6, %7 - br i1 %8, label %condContinue__1, label %condFalse__1 - -condFalse__1: ; preds = %body__1 - %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) - %10 = bitcast i8* %9 to i2* - %11 = load i2, i2* %10, align 1 - %12 = load i2, i2* @PauliI, align 1 - %13 = icmp eq i2 %11, %12 - br label %condContinue__1 - -condContinue__1: ; preds = %condFalse__1, %body__1 - %14 = phi i1 [ %8, %body__1 ], [ %13, %condFalse__1 ] - br i1 %14, label %then0__1, label %continue__1 - -then0__1: ; preds = %condContinue__1 - store i1 true, i1* %haveY, align 1 - br label %continue__1 - -continue__1: ; preds = %then0__1, %condContinue__1 - br label %exiting__1 - -exiting__1: ; preds = %continue__1 - %15 = add i64 %i, 1 - br label %header__1 - -exit__1: ; preds = %header__1 - %16 = load i1, i1* %haveY, align 1 - br i1 %16, label %then0__2, label %test1__1 - -then0__2: ; preds = %exit__1 - %17 = call %Result* @__quantum__qis__joint_measure(i64 106, i64 1, %Array* %qubits) - call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 1) - store %Result* %17, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %0, i32 -1) - br label %continue__2 - -test1__1: ; preds = %exit__1 - %18 = icmp sgt i64 %1, 2 - br i1 %18, label %then1__1, label %test2__1 - -then1__1: ; preds = %test1__1 - %19 = call %Result* @__quantum__qis__joint_measure(i64 107, i64 1, %Array* %qubits) - call void @__quantum__rt__result_update_reference_count(%Result* %19, i32 1) - %20 = load %Result*, %Result** %res, align 8 - store %Result* %19, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %19, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %20, i32 -1) - br label %continue__2 - -test2__1: ; preds = %test1__1 - %21 = icmp eq i64 %1, 1 - br i1 %21, label %then2__1, label %test3__1 - -then2__1: ; preds = %test2__1 - %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %23 = bitcast i8* %22 to i2* - %24 = load i2, i2* %23, align 1 - %25 = load i2, i2* @PauliX, align 1 - %26 = icmp eq i2 %24, %25 - br i1 %26, label %then0__3, label %else__1 - -then0__3: ; preds = %then2__1 - %27 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) - %28 = bitcast i8* %27 to %Qubit** - %qb = load %Qubit*, %Qubit** %28, align 8 - %29 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb) - call void @__quantum__rt__result_update_reference_count(%Result* %29, i32 1) - %30 = load %Result*, %Result** %res, align 8 - store %Result* %29, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %29, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %30, i32 -1) - br label %continue__3 - -else__1: ; preds = %then2__1 - %31 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) - %32 = bitcast i8* %31 to %Qubit** - %qb__1 = load %Qubit*, %Qubit** %32, align 8 - %33 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__1) - call void @__quantum__rt__result_update_reference_count(%Result* %33, i32 1) - %34 = load %Result*, %Result** %res, align 8 - store %Result* %33, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %33, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %34, i32 -1) - br label %continue__3 - -continue__3: ; preds = %else__1, %then0__3 - br label %continue__2 - -test3__1: ; preds = %test2__1 - %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %36 = bitcast i8* %35 to i2* - %37 = load i2, i2* %36, align 1 - %38 = load i2, i2* @PauliX, align 1 - %39 = icmp eq i2 %37, %38 - br i1 %39, label %condTrue__1, label %condContinue__2 - -condTrue__1: ; preds = %test3__1 - %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %41 = bitcast i8* %40 to i2* - %42 = load i2, i2* %41, align 1 - %43 = load i2, i2* @PauliX, align 1 - %44 = icmp eq i2 %42, %43 - br label %condContinue__2 - -condContinue__2: ; preds = %condTrue__1, %test3__1 - %45 = phi i1 [ %44, %condTrue__1 ], [ %39, %test3__1 ] - br i1 %45, label %then3__1, label %test4__1 - -then3__1: ; preds = %condContinue__2 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %46 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %46, i32 1) - %47 = load %Result*, %Result** %res, align 8 - store %Result* %46, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %46, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %47, i32 -1) - br label %continue__2 - -test4__1: ; preds = %condContinue__2 - %48 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %49 = bitcast i8* %48 to i2* - %50 = load i2, i2* %49, align 1 - %51 = load i2, i2* @PauliX, align 1 - %52 = icmp eq i2 %50, %51 - br i1 %52, label %condTrue__2, label %condContinue__3 - -condTrue__2: ; preds = %test4__1 - %53 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %54 = bitcast i8* %53 to i2* - %55 = load i2, i2* %54, align 1 - %56 = load i2, i2* @PauliZ, align 1 - %57 = icmp eq i2 %55, %56 - br label %condContinue__3 - -condContinue__3: ; preds = %condTrue__2, %test4__1 - %58 = phi i1 [ %57, %condTrue__2 ], [ %52, %test4__1 ] - br i1 %58, label %then4__1, label %test5__1 - -then4__1: ; preds = %condContinue__3 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %59 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %59, i32 1) - %60 = load %Result*, %Result** %res, align 8 - store %Result* %59, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %59, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %60, i32 -1) - br label %continue__2 - -test5__1: ; preds = %condContinue__3 - %61 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %62 = bitcast i8* %61 to i2* - %63 = load i2, i2* %62, align 1 - %64 = load i2, i2* @PauliZ, align 1 - %65 = icmp eq i2 %63, %64 - br i1 %65, label %condTrue__3, label %condContinue__4 - -condTrue__3: ; preds = %test5__1 - %66 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %67 = bitcast i8* %66 to i2* - %68 = load i2, i2* %67, align 1 - %69 = load i2, i2* @PauliX, align 1 - %70 = icmp eq i2 %68, %69 - br label %condContinue__4 - -condContinue__4: ; preds = %condTrue__3, %test5__1 - %71 = phi i1 [ %70, %condTrue__3 ], [ %65, %test5__1 ] - br i1 %71, label %then5__1, label %test6__1 - -then5__1: ; preds = %condContinue__4 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %72 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %72, i32 1) - %73 = load %Result*, %Result** %res, align 8 - store %Result* %72, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %72, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %73, i32 -1) - br label %continue__2 - -test6__1: ; preds = %condContinue__4 - %74 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %75 = bitcast i8* %74 to i2* - %76 = load i2, i2* %75, align 1 - %77 = load i2, i2* @PauliZ, align 1 - %78 = icmp eq i2 %76, %77 - br i1 %78, label %condTrue__4, label %condContinue__5 - -condTrue__4: ; preds = %test6__1 - %79 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %80 = bitcast i8* %79 to i2* - %81 = load i2, i2* %80, align 1 - %82 = load i2, i2* @PauliZ, align 1 - %83 = icmp eq i2 %81, %82 - br label %condContinue__5 - -condContinue__5: ; preds = %condTrue__4, %test6__1 - %84 = phi i1 [ %83, %condTrue__4 ], [ %78, %test6__1 ] - br i1 %84, label %then6__1, label %continue__2 - -then6__1: ; preds = %condContinue__5 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %85 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %85, i32 1) - %86 = load %Result*, %Result** %res, align 8 - store %Result* %85, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %85, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %86, i32 -1) - br label %continue__2 - -continue__2: ; preds = %then6__1, %condContinue__5, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 - %87 = load %Result*, %Result** %res, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %87 -} - -declare %Result* @__quantum__rt__result_get_one() - -define void @Microsoft__Quantum__Intrinsic__Rx__body(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rx__adj(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rx__ctl(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rx__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Ry__body(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Ry__adj(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Ry__ctl(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Ry__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rz__body(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rz__adj(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rz__ctl(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rz__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 4, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 5, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 4, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 5, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 7, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 8, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 7, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 8, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Testing__Tracer__Delay__body(%Callable* %op, %Qubit* %arg, %Tuple* %aux) { -entry: - call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 1) - %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) - %1 = bitcast %Tuple* %0 to { %Qubit* }* - %2 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %1, i32 0, i32 0 - store %Qubit* %arg, %Qubit** %2, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %op, %Tuple* %0, %Tuple* null) - call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %0, i32 -1) - ret void -} - -declare void @__quantum__rt__callable_invoke(%Callable*, %Tuple*, %Tuple*) - -define void @Microsoft__Quantum__Testing__Tracer__TestCoreIntrinsics__body() { -entry: - %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 3) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %1 = bitcast i8* %0 to %Qubit** - %qb = load %Qubit*, %Qubit** %1, align 8 - call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb) - %2 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %3 = bitcast i8* %2 to %Qubit** - %qb__1 = load %Qubit*, %Qubit** %3, align 8 - call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb__1) - %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %5 = bitcast i8* %4 to %Qubit** - %qb__2 = load %Qubit*, %Qubit** %5, align 8 - call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb__2) - %6 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %7 = bitcast i8* %6 to %Qubit** - %qb__3 = load %Qubit*, %Qubit** %7, align 8 - call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb__3) - %8 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %9 = bitcast i8* %8 to %Qubit** - %10 = load %Qubit*, %Qubit** %9, align 8 - %11 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %12 = bitcast i8* %11 to %Qubit** - %13 = load %Qubit*, %Qubit** %12, align 8 - call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %10, %Qubit* %13) - %14 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %15 = bitcast i8* %14 to %Qubit** - %qb__4 = load %Qubit*, %Qubit** %15, align 8 - call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__4) - %16 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %17 = bitcast i8* %16 to %Qubit** - %qb__5 = load %Qubit*, %Qubit** %17, align 8 - call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb__5) - %18 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %19 = bitcast i8* %18 to %Qubit** - %qb__6 = load %Qubit*, %Qubit** %19, align 8 - call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb__6) - %20 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %21 = bitcast i8* %20 to %Qubit** - %qb__7 = load %Qubit*, %Qubit** %21, align 8 - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb__7) - %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %23 = bitcast i8* %22 to %Qubit** - %qb__9 = load %Qubit*, %Qubit** %23, align 8 - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__9) - call void @__quantum__qis__inject_barrier(i64 42, i64 0) - %24 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %25 = bitcast i8* %24 to %Qubit** - %qb__11 = load %Qubit*, %Qubit** %25, align 8 - call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb__11) - %26 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %27 = bitcast i8* %26 to %Qubit** - %qb__13 = load %Qubit*, %Qubit** %27, align 8 - call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb__13) - %28 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %29 = bitcast i8* %28 to %Qubit** - %qb__15 = load %Qubit*, %Qubit** %29, align 8 - call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb__15) - %30 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %31 = bitcast i8* %30 to %Qubit** - %qb__17 = load %Qubit*, %Qubit** %31, align 8 - call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb__17) - %32 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %33 = bitcast i8* %32 to %Qubit** - %34 = load %Qubit*, %Qubit** %33, align 8 - %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %36 = bitcast i8* %35 to %Qubit** - %37 = load %Qubit*, %Qubit** %36, align 8 - call void @Microsoft__Quantum__Intrinsic__CNOT__adj(%Qubit* %34, %Qubit* %37) - %38 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %39 = bitcast i8* %38 to %Qubit** - %qb__19 = load %Qubit*, %Qubit** %39, align 8 - call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__19) - %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %41 = bitcast i8* %40 to %Qubit** - %qb__20 = load %Qubit*, %Qubit** %41, align 8 - call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb__20) - %42 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %43 = bitcast i8* %42 to %Qubit** - %qb__21 = load %Qubit*, %Qubit** %43, align 8 - call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb__21) - %44 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %45 = bitcast i8* %44 to %Qubit** - %qb__22 = load %Qubit*, %Qubit** %45, align 8 - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb__22) - %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %47 = bitcast i8* %46 to %Qubit** - %qb__24 = load %Qubit*, %Qubit** %47, align 8 - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__24) - %c = call %Qubit* @__quantum__rt__qubit_allocate() - %ctls = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %48 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %49 = bitcast i8* %48 to %Qubit** - store %Qubit* %c, %Qubit** %49, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %50 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %51 = bitcast i8* %50 to %Qubit** - %qb__26 = load %Qubit*, %Qubit** %51, align 8 - br i1 true, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %ctls, %Qubit* %qb__26) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %ctls, %Qubit* %qb__26) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i32 -1) - %ctls__1 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %52 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__1, i64 0) - %53 = bitcast i8* %52 to %Qubit** - store %Qubit* %c, %Qubit** %53, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 1) - %54 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %55 = bitcast i8* %54 to %Qubit** - %qb__27 = load %Qubit*, %Qubit** %55, align 8 - br i1 true, label %then0__2, label %else__2 - -then0__2: ; preds = %continue__1 - call void @__quantum__qis__single_qubit_op_ctl(i64 4, i64 1, %Array* %ctls__1, %Qubit* %qb__27) - br label %continue__2 - -else__2: ; preds = %continue__1 - call void @__quantum__qis__single_qubit_op_ctl(i64 5, i64 1, %Array* %ctls__1, %Qubit* %qb__27) - br label %continue__2 - -continue__2: ; preds = %else__2, %then0__2 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i32 -1) - %ctls__2 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %56 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__2, i64 0) - %57 = bitcast i8* %56 to %Qubit** - store %Qubit* %c, %Qubit** %57, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i32 1) - %58 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %59 = bitcast i8* %58 to %Qubit** - %qb__28 = load %Qubit*, %Qubit** %59, align 8 - br i1 true, label %then0__3, label %else__3 - -then0__3: ; preds = %continue__2 - call void @__quantum__qis__single_qubit_op_ctl(i64 7, i64 1, %Array* %ctls__2, %Qubit* %qb__28) - br label %continue__3 - -else__3: ; preds = %continue__2 - call void @__quantum__qis__single_qubit_op_ctl(i64 8, i64 1, %Array* %ctls__2, %Qubit* %qb__28) - br label %continue__3 - -continue__3: ; preds = %else__3, %then0__3 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__2, i32 -1) - %ctls__3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %60 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__3, i64 0) - %61 = bitcast i8* %60 to %Qubit** - store %Qubit* %c, %Qubit** %61, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i32 1) - %62 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %63 = bitcast i8* %62 to %Qubit** - %qb__29 = load %Qubit*, %Qubit** %63, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %ctls__3, %Qubit* %qb__29) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__3, i32 -1) - %ctls__4 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %64 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__4, i64 0) - %65 = bitcast i8* %64 to %Qubit** - store %Qubit* %c, %Qubit** %65, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i32 1) - %66 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %67 = bitcast i8* %66 to %Qubit** - %qb__30 = load %Qubit*, %Qubit** %67, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls__4, %Qubit* %qb__30) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__4, i32 -1) - %ctls__5 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %68 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__5, i64 0) - %69 = bitcast i8* %68 to %Qubit** - store %Qubit* %c, %Qubit** %69, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i32 1) - %70 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %71 = bitcast i8* %70 to %Qubit** - %qb__31 = load %Qubit*, %Qubit** %71, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls__5, %Qubit* %qb__31) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__5, i32 -1) - %ctls__6 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %72 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__6, i64 0) - %73 = bitcast i8* %72 to %Qubit** - store %Qubit* %c, %Qubit** %73, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i32 1) - %74 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %75 = bitcast i8* %74 to %Qubit** - %qb__32 = load %Qubit*, %Qubit** %75, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls__6, %Qubit* %qb__32) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__6, i32 -1) - %ctls__7 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %76 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__7, i64 0) - %77 = bitcast i8* %76 to %Qubit** - store %Qubit* %c, %Qubit** %77, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 1) - %78 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %79 = bitcast i8* %78 to %Qubit** - %qb__33 = load %Qubit*, %Qubit** %79, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls__7, %Qubit* %qb__33) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__7, i32 -1) - %ctls__9 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %80 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__9, i64 0) - %81 = bitcast i8* %80 to %Qubit** - store %Qubit* %c, %Qubit** %81, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 1) - %82 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %83 = bitcast i8* %82 to %Qubit** - %qb__35 = load %Qubit*, %Qubit** %83, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls__9, %Qubit* %qb__35) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__9, i32 -1) - call void @__quantum__rt__qubit_release(%Qubit* %c) - %cc = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %84 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %85 = bitcast i8* %84 to %Qubit** - %qb__37 = load %Qubit*, %Qubit** %85, align 8 - %86 = call i64 @__quantum__rt__array_get_size_1d(%Array* %cc) - %87 = icmp eq i64 %86, 1 - br i1 %87, label %then0__4, label %else__4 - -then0__4: ; preds = %continue__3 - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %cc, %Qubit* %qb__37) - br label %continue__4 - -else__4: ; preds = %continue__3 - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %cc, %Qubit* %qb__37) - br label %continue__4 - -continue__4: ; preds = %else__4, %then0__4 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %88 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %89 = bitcast i8* %88 to %Qubit** - %qb__38 = load %Qubit*, %Qubit** %89, align 8 - %90 = icmp eq i64 %86, 1 - br i1 %90, label %then0__5, label %else__5 - -then0__5: ; preds = %continue__4 - call void @__quantum__qis__single_qubit_op_ctl(i64 4, i64 1, %Array* %cc, %Qubit* %qb__38) - br label %continue__5 - -else__5: ; preds = %continue__4 - call void @__quantum__qis__single_qubit_op_ctl(i64 5, i64 1, %Array* %cc, %Qubit* %qb__38) - br label %continue__5 - -continue__5: ; preds = %else__5, %then0__5 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %91 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %92 = bitcast i8* %91 to %Qubit** - %qb__39 = load %Qubit*, %Qubit** %92, align 8 - %93 = icmp eq i64 %86, 1 - br i1 %93, label %then0__6, label %else__6 - -then0__6: ; preds = %continue__5 - call void @__quantum__qis__single_qubit_op_ctl(i64 7, i64 1, %Array* %cc, %Qubit* %qb__39) - br label %continue__6 - -else__6: ; preds = %continue__5 - call void @__quantum__qis__single_qubit_op_ctl(i64 8, i64 1, %Array* %cc, %Qubit* %qb__39) - br label %continue__6 - -continue__6: ; preds = %else__6, %then0__6 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %94 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %95 = bitcast i8* %94 to %Qubit** - %qb__40 = load %Qubit*, %Qubit** %95, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %cc, %Qubit* %qb__40) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %96 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %97 = bitcast i8* %96 to %Qubit** - %qb__41 = load %Qubit*, %Qubit** %97, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %cc, %Qubit* %qb__41) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %98 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %99 = bitcast i8* %98 to %Qubit** - %qb__42 = load %Qubit*, %Qubit** %99, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %cc, %Qubit* %qb__42) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %100 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %101 = bitcast i8* %100 to %Qubit** - %qb__43 = load %Qubit*, %Qubit** %101, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %cc, %Qubit* %qb__43) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %102 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %103 = bitcast i8* %102 to %Qubit** - %qb__44 = load %Qubit*, %Qubit** %103, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %cc, %Qubit* %qb__44) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %104 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %105 = bitcast i8* %104 to %Qubit** - %qb__46 = load %Qubit*, %Qubit** %105, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %cc, %Qubit* %qb__46) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__qubit_release_array(%Array* %cc) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) - call void @__quantum__rt__qubit_release_array(%Array* %qs) - ret void -} - -declare %Qubit* @__quantum__rt__qubit_allocate() - -declare %Array* @__quantum__rt__qubit_allocate_array(i64) - -declare void @__quantum__qis__inject_barrier(i64, i64) - -declare void @__quantum__rt__qubit_release(%Qubit*) - -declare void @__quantum__rt__qubit_release_array(%Array*) - -define void @Microsoft__Quantum__Testing__Tracer__TestMeasurements__body() { -entry: - %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 6) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %1 = bitcast i8* %0 to %Qubit** - %qb = load %Qubit*, %Qubit** %1, align 8 - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - %2 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %3 = bitcast i8* %2 to %Qubit** - %qb__2 = load %Qubit*, %Qubit** %3, align 8 - %r0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__2) - %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %5 = bitcast i8* %4 to %Qubit** - %qb__4 = load %Qubit*, %Qubit** %5, align 8 - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__4) - %6 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %7 = bitcast i8* %6 to %Qubit** - %8 = load %Qubit*, %Qubit** %7, align 8 - %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %10 = bitcast i8* %9 to %Qubit** - %11 = load %Qubit*, %Qubit** %10, align 8 - call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %8, %Qubit* %11) - %qs12 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 2) - %12 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) - %13 = bitcast i8* %12 to %Qubit** - %14 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 1) - %15 = bitcast i8* %14 to %Qubit** - %16 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %17 = bitcast i8* %16 to %Qubit** - %18 = load %Qubit*, %Qubit** %17, align 8 - %19 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %20 = bitcast i8* %19 to %Qubit** - %21 = load %Qubit*, %Qubit** %20, align 8 - store %Qubit* %18, %Qubit** %13, align 8 - store %Qubit* %21, %Qubit** %15, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %paulis = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %23 = bitcast i8* %22 to i2* - %24 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %25 = bitcast i8* %24 to i2* - %26 = load i2, i2* @PauliY, align 1 - %27 = load i2, i2* @PauliX, align 1 - store i2 %26, i2* %23, align 1 - store i2 %27, i2* %25, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %28 = call %Result* @__quantum__rt__result_get_one() - %res = alloca %Result*, align 8 - store %Result* %28, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %28, i32 1) - %haveY = alloca i1, align 1 - store i1 false, i1* %haveY, align 1 - br label %header__1 - -header__1: ; preds = %exiting__1, %entry - %i = phi i64 [ 0, %entry ], [ %41, %exiting__1 ] - %29 = icmp sle i64 %i, 1 - br i1 %29, label %body__1, label %exit__1 - -body__1: ; preds = %header__1 - %30 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) - %31 = bitcast i8* %30 to i2* - %32 = load i2, i2* %31, align 1 - %33 = load i2, i2* @PauliY, align 1 - %34 = icmp eq i2 %32, %33 - br i1 %34, label %condContinue__1, label %condFalse__1 - -condFalse__1: ; preds = %body__1 - %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) - %36 = bitcast i8* %35 to i2* - %37 = load i2, i2* %36, align 1 - %38 = load i2, i2* @PauliI, align 1 - %39 = icmp eq i2 %37, %38 - br label %condContinue__1 - -condContinue__1: ; preds = %condFalse__1, %body__1 - %40 = phi i1 [ %34, %body__1 ], [ %39, %condFalse__1 ] - br i1 %40, label %then0__1, label %continue__1 - -then0__1: ; preds = %condContinue__1 - store i1 true, i1* %haveY, align 1 - br label %continue__1 - -continue__1: ; preds = %then0__1, %condContinue__1 - br label %exiting__1 - -exiting__1: ; preds = %continue__1 - %41 = add i64 %i, 1 - br label %header__1 - -exit__1: ; preds = %header__1 - %42 = load i1, i1* %haveY, align 1 - br i1 %42, label %then0__2, label %test1__1 - -then0__2: ; preds = %exit__1 - %43 = call %Result* @__quantum__qis__joint_measure(i64 106, i64 1, %Array* %qs12) - call void @__quantum__rt__result_update_reference_count(%Result* %43, i32 1) - store %Result* %43, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %43, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %28, i32 -1) - br label %continue__2 - -test1__1: ; preds = %exit__1 - br i1 false, label %then1__1, label %test2__1 - -then1__1: ; preds = %test1__1 - %44 = call %Result* @__quantum__qis__joint_measure(i64 107, i64 1, %Array* %qs12) - call void @__quantum__rt__result_update_reference_count(%Result* %44, i32 1) - %45 = load %Result*, %Result** %res, align 8 - store %Result* %44, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %44, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %45, i32 -1) - br label %continue__2 - -test2__1: ; preds = %test1__1 - br i1 false, label %then2__1, label %test3__1 - -then2__1: ; preds = %test2__1 - %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %47 = bitcast i8* %46 to i2* - %48 = load i2, i2* %47, align 1 - %49 = load i2, i2* @PauliX, align 1 - %50 = icmp eq i2 %48, %49 - br i1 %50, label %then0__3, label %else__1 - -then0__3: ; preds = %then2__1 - %51 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) - %52 = bitcast i8* %51 to %Qubit** - %qb__6 = load %Qubit*, %Qubit** %52, align 8 - %53 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb__6) - call void @__quantum__rt__result_update_reference_count(%Result* %53, i32 1) - %54 = load %Result*, %Result** %res, align 8 - store %Result* %53, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %53, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %54, i32 -1) - br label %continue__3 - -else__1: ; preds = %then2__1 - %55 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) - %56 = bitcast i8* %55 to %Qubit** - %qb__7 = load %Qubit*, %Qubit** %56, align 8 - %57 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__7) - call void @__quantum__rt__result_update_reference_count(%Result* %57, i32 1) - %58 = load %Result*, %Result** %res, align 8 - store %Result* %57, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %57, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %58, i32 -1) - br label %continue__3 - -continue__3: ; preds = %else__1, %then0__3 - br label %continue__2 - -test3__1: ; preds = %test2__1 - %59 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %60 = bitcast i8* %59 to i2* - %61 = load i2, i2* %60, align 1 - %62 = load i2, i2* @PauliX, align 1 - %63 = icmp eq i2 %61, %62 - br i1 %63, label %condTrue__1, label %condContinue__2 - -condTrue__1: ; preds = %test3__1 - %64 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %65 = bitcast i8* %64 to i2* - %66 = load i2, i2* %65, align 1 - %67 = load i2, i2* @PauliX, align 1 - %68 = icmp eq i2 %66, %67 - br label %condContinue__2 - -condContinue__2: ; preds = %condTrue__1, %test3__1 - %69 = phi i1 [ %68, %condTrue__1 ], [ %63, %test3__1 ] - br i1 %69, label %then3__1, label %test4__1 - -then3__1: ; preds = %condContinue__2 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %70 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %70, i32 1) - %71 = load %Result*, %Result** %res, align 8 - store %Result* %70, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %70, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %71, i32 -1) - br label %continue__2 - -test4__1: ; preds = %condContinue__2 - %72 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %73 = bitcast i8* %72 to i2* - %74 = load i2, i2* %73, align 1 - %75 = load i2, i2* @PauliX, align 1 - %76 = icmp eq i2 %74, %75 - br i1 %76, label %condTrue__2, label %condContinue__3 - -condTrue__2: ; preds = %test4__1 - %77 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %78 = bitcast i8* %77 to i2* - %79 = load i2, i2* %78, align 1 - %80 = load i2, i2* @PauliZ, align 1 - %81 = icmp eq i2 %79, %80 - br label %condContinue__3 - -condContinue__3: ; preds = %condTrue__2, %test4__1 - %82 = phi i1 [ %81, %condTrue__2 ], [ %76, %test4__1 ] - br i1 %82, label %then4__1, label %test5__1 - -then4__1: ; preds = %condContinue__3 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %83 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %83, i32 1) - %84 = load %Result*, %Result** %res, align 8 - store %Result* %83, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %83, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %84, i32 -1) - br label %continue__2 - -test5__1: ; preds = %condContinue__3 - %85 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %86 = bitcast i8* %85 to i2* - %87 = load i2, i2* %86, align 1 - %88 = load i2, i2* @PauliZ, align 1 - %89 = icmp eq i2 %87, %88 - br i1 %89, label %condTrue__3, label %condContinue__4 - -condTrue__3: ; preds = %test5__1 - %90 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %91 = bitcast i8* %90 to i2* - %92 = load i2, i2* %91, align 1 - %93 = load i2, i2* @PauliX, align 1 - %94 = icmp eq i2 %92, %93 - br label %condContinue__4 - -condContinue__4: ; preds = %condTrue__3, %test5__1 - %95 = phi i1 [ %94, %condTrue__3 ], [ %89, %test5__1 ] - br i1 %95, label %then5__1, label %test6__1 - -then5__1: ; preds = %condContinue__4 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %96 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %96, i32 1) - %97 = load %Result*, %Result** %res, align 8 - store %Result* %96, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %96, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %97, i32 -1) - br label %continue__2 - -test6__1: ; preds = %condContinue__4 - %98 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %99 = bitcast i8* %98 to i2* - %100 = load i2, i2* %99, align 1 - %101 = load i2, i2* @PauliZ, align 1 - %102 = icmp eq i2 %100, %101 - br i1 %102, label %condTrue__4, label %condContinue__5 - -condTrue__4: ; preds = %test6__1 - %103 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %104 = bitcast i8* %103 to i2* - %105 = load i2, i2* %104, align 1 - %106 = load i2, i2* @PauliZ, align 1 - %107 = icmp eq i2 %105, %106 - br label %condContinue__5 - -condContinue__5: ; preds = %condTrue__4, %test6__1 - %108 = phi i1 [ %107, %condTrue__4 ], [ %102, %test6__1 ] - br i1 %108, label %then6__1, label %continue__2 - -then6__1: ; preds = %condContinue__5 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %109 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %109, i32 1) - %110 = load %Result*, %Result** %res, align 8 - store %Result* %109, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %109, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %110, i32 -1) - br label %continue__2 - -continue__2: ; preds = %then6__1, %condContinue__5, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 - %r12 = load %Result*, %Result** %res, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis, i32 -1) - %111 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %112 = bitcast %Tuple* %111 to { %Callable*, %Callable*, %Qubit* }* - %113 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 0 - %114 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 1 - %115 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 2 - %116 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %117 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__X, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %118 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 3) - %119 = bitcast i8* %118 to %Qubit** - %120 = load %Qubit*, %Qubit** %119, align 8 - store %Callable* %116, %Callable** %113, align 8 - store %Callable* %117, %Callable** %114, align 8 - store %Qubit* %120, %Qubit** %115, align 8 - %121 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__1, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %111) - %122 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %123 = bitcast %Tuple* %122 to { %Callable*, %Callable*, %Qubit* }* - %124 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 0 - %125 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 1 - %126 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 2 - %127 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %128 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Y, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %129 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 3) - %130 = bitcast i8* %129 to %Qubit** - %131 = load %Qubit*, %Qubit** %130, align 8 - store %Callable* %127, %Callable** %124, align 8 - store %Callable* %128, %Callable** %125, align 8 - store %Qubit* %131, %Qubit** %126, align 8 - %132 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__2, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %122) - call void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %r0, %Callable* %121, %Callable* %132) - %133 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %134 = bitcast %Tuple* %133 to { %Callable*, %Callable*, %Qubit* }* - %135 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 0 - %136 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 1 - %137 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 2 - %138 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %139 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Z, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %140 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 4) - %141 = bitcast i8* %140 to %Qubit** - %142 = load %Qubit*, %Qubit** %141, align 8 - store %Callable* %138, %Callable** %135, align 8 - store %Callable* %139, %Callable** %136, align 8 - store %Qubit* %142, %Qubit** %137, align 8 - %143 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__3, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %133) - %144 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %145 = bitcast %Tuple* %144 to { %Callable*, %Callable*, %Qubit* }* - %146 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 0 - %147 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 1 - %148 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 2 - %149 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %150 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__S, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %151 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 4) - %152 = bitcast i8* %151 to %Qubit** - %153 = load %Qubit*, %Qubit** %152, align 8 - store %Callable* %149, %Callable** %146, align 8 - store %Callable* %150, %Callable** %147, align 8 - store %Qubit* %153, %Qubit** %148, align 8 - %154 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__4, [2 x void (%Tuple*, i32)*]* @MemoryManagement__2, %Tuple* %144) - call void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %r12, %Callable* %143, %Callable* %154) - %155 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 5) - %156 = bitcast i8* %155 to %Qubit** - %qb__8 = load %Qubit*, %Qubit** %156, align 8 - call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__8) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %r0, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %r12, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %121, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %121, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %132, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %132, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %143, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %143, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %154, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %154, i32 -1) - call void @__quantum__rt__qubit_release_array(%Array* %qs) - ret void -} - -define void @Microsoft__Quantum__Testing__Tracer__Delay__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Callable*, %Qubit*, %Tuple* }* - %1 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 1 - %3 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 2 - %4 = load %Callable*, %Callable** %1, align 8 - %5 = load %Qubit*, %Qubit** %2, align 8 - %6 = load %Tuple*, %Tuple** %3, align 8 - call void @Microsoft__Quantum__Testing__Tracer__Delay__body(%Callable* %4, %Qubit* %5, %Tuple* %6) - ret void -} - -declare %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]*, [2 x void (%Tuple*, i32)*]*, %Tuple*) - -define void @Microsoft__Quantum__Intrinsic__X__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Lifted__PartialApplication__1__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1, align 8 - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* - %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* - %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10, align 8 - store %Qubit* %4, %Qubit** %11, align 8 - store %Tuple* %7, %Tuple** %12, align 8 - %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - ret void -} - -define void @MemoryManagement__1__RefCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3, align 8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -define void @MemoryManagement__1__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3, align 8 - call void @__quantum__rt__capture_update_alias_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Lifted__PartialApplication__2__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1, align 8 - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* - %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* - %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10, align 8 - store %Qubit* %4, %Qubit** %11, align 8 - store %Tuple* %7, %Tuple** %12, align 8 - %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Lifted__PartialApplication__3__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1, align 8 - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* - %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* - %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10, align 8 - store %Qubit* %4, %Qubit** %11, align 8 - store %Tuple* %7, %Tuple** %12, align 8 - %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Lifted__PartialApplication__4__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1, align 8 - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* - %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* - %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10, align 8 - store %Qubit* %4, %Qubit** %11, align 8 - store %Tuple* %7, %Tuple** %12, align 8 - %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - ret void -} - -define void @MemoryManagement__2__RefCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3, align 8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -define void @MemoryManagement__2__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3, align 8 - call void @__quantum__rt__capture_update_alias_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -declare void @__quantum__rt__capture_update_reference_count(%Callable*, i32) - -declare void @__quantum__rt__callable_update_reference_count(%Callable*, i32) - -define %Tuple* @Microsoft__Quantum__Core__Attribute__body() { -entry: - ret %Tuple* null -} - -define %Tuple* @Microsoft__Quantum__Core__EntryPoint__body() { -entry: - ret %Tuple* null -} - -define %Tuple* @Microsoft__Quantum__Core__Inline__body() { -entry: - ret %Tuple* null -} - -define { %String* }* @Microsoft__Quantum__Targeting__TargetInstruction__body(%String* %__Item1__) { -entry: - %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) - %1 = bitcast %Tuple* %0 to { %String* }* - %2 = getelementptr inbounds { %String* }, { %String* }* %1, i32 0, i32 0 - store %String* %__Item1__, %String** %2, align 8 - call void @__quantum__rt__string_update_reference_count(%String* %__Item1__, i32 1) - ret { %String* }* %1 -} - -declare void @__quantum__rt__string_update_reference_count(%String*, i32) - -declare void @__quantum__rt__tuple_update_alias_count(%Tuple*, i32) From 3c418deb2c62a8cb9c7f4676bb7757386439729a Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Thu, 18 Mar 2021 12:07:25 -0700 Subject: [PATCH 13/14] Removed auto-gen files --- .../qir-standalone-input-reference.ll | 89 - .../FullstateSimulator/qir-test-simulator.ll | 1367 ----------- .../test/QIR-dynamic/qir-test-random.ll | 142 -- src/QirRuntime/test/QIR-tracer/tracer-qir.ll | 2080 ----------------- 4 files changed, 3678 deletions(-) delete mode 100644 src/QirRuntime/samples/StandaloneInputReference/qir-standalone-input-reference.ll delete mode 100644 src/QirRuntime/test/FullstateSimulator/qir-test-simulator.ll delete mode 100644 src/QirRuntime/test/QIR-dynamic/qir-test-random.ll delete mode 100644 src/QirRuntime/test/QIR-tracer/tracer-qir.ll diff --git a/src/QirRuntime/samples/StandaloneInputReference/qir-standalone-input-reference.ll b/src/QirRuntime/samples/StandaloneInputReference/qir-standalone-input-reference.ll deleted file mode 100644 index 29f506d0d40..00000000000 --- a/src/QirRuntime/samples/StandaloneInputReference/qir-standalone-input-reference.ll +++ /dev/null @@ -1,89 +0,0 @@ - -%Range = type { i64, i64, i64 } -%Result = type opaque -%String = type opaque - -@PauliI = constant i2 0 -@PauliX = constant i2 1 -@PauliY = constant i2 -1 -@PauliZ = constant i2 -2 -@EmptyRange = internal constant %Range { i64 0, i64 1, i64 -1 } -@0 = internal constant [26 x i8] c"Exercise Supported Inputs\00" -@1 = internal constant [11 x i8] c"intValue: \00" -@2 = internal constant [14 x i8] c"doubleValue: \00" -@3 = internal constant [14 x i8] c"resultValue: \00" -@4 = internal constant [14 x i8] c"stringValue: \00" - -define i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs__body(i64 %intValue, double %doubleValue, %Result* %resultValue, %String* %stringValue) { -entry: - %msg = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @0, i32 0, i32 0)) - call void @__quantum__qis__message__body(%String* %msg) - call void @__quantum__rt__string_update_reference_count(%String* %msg, i32 -1) - %0 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @1, i32 0, i32 0)) - %1 = call %String* @__quantum__rt__int_to_string(i64 %intValue) - %msg__1 = call %String* @__quantum__rt__string_concatenate(%String* %0, %String* %1) - call void @__quantum__rt__string_update_reference_count(%String* %0, i32 -1) - call void @__quantum__rt__string_update_reference_count(%String* %1, i32 -1) - call void @__quantum__qis__message__body(%String* %msg__1) - call void @__quantum__rt__string_update_reference_count(%String* %msg__1, i32 -1) - %2 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @2, i32 0, i32 0)) - %3 = call %String* @__quantum__rt__double_to_string(double %doubleValue) - %msg__2 = call %String* @__quantum__rt__string_concatenate(%String* %2, %String* %3) - call void @__quantum__rt__string_update_reference_count(%String* %2, i32 -1) - call void @__quantum__rt__string_update_reference_count(%String* %3, i32 -1) - call void @__quantum__qis__message__body(%String* %msg__2) - call void @__quantum__rt__string_update_reference_count(%String* %msg__2, i32 -1) - %4 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @3, i32 0, i32 0)) - %5 = call %String* @__quantum__rt__result_to_string(%Result* %resultValue) - %msg__3 = call %String* @__quantum__rt__string_concatenate(%String* %4, %String* %5) - call void @__quantum__rt__string_update_reference_count(%String* %4, i32 -1) - call void @__quantum__rt__string_update_reference_count(%String* %5, i32 -1) - call void @__quantum__qis__message__body(%String* %msg__3) - call void @__quantum__rt__string_update_reference_count(%String* %msg__3, i32 -1) - %6 = call %String* @__quantum__rt__string_create(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @4, i32 0, i32 0)) - call void @__quantum__rt__string_update_reference_count(%String* %stringValue, i32 1) - %msg__4 = call %String* @__quantum__rt__string_concatenate(%String* %6, %String* %stringValue) - call void @__quantum__rt__string_update_reference_count(%String* %6, i32 -1) - call void @__quantum__rt__string_update_reference_count(%String* %stringValue, i32 -1) - call void @__quantum__qis__message__body(%String* %msg__4) - call void @__quantum__rt__string_update_reference_count(%String* %msg__4, i32 -1) - ret i64 0 -} - -declare %String* @__quantum__rt__string_create(i8*) - -declare void @__quantum__qis__message__body(%String*) - -declare void @__quantum__rt__string_update_reference_count(%String*, i32) - -declare %String* @__quantum__rt__int_to_string(i64) - -declare %String* @__quantum__rt__string_concatenate(%String*, %String*) - -declare %String* @__quantum__rt__double_to_string(double) - -declare %String* @__quantum__rt__result_to_string(%Result*) - -define void @Microsoft__Quantum__Intrinsic__Message__body(%String* %msg) { -entry: - call void @__quantum__qis__message__body(%String* %msg) - ret void -} - -define i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs(i64 %intValue, double %doubleValue, i8 %resultValue, i8* %stringValue) #0 { -entry: - %0 = icmp eq i8 %resultValue, 0 - %1 = call %Result* @__quantum__rt__result_get_zero() - %2 = call %Result* @__quantum__rt__result_get_one() - %3 = select i1 %0, %Result* %1, %Result* %2 - %4 = call %String* @__quantum__rt__string_create(i8* %stringValue) - %5 = call i64 @Quantum__StandaloneSupportedInputs__ExerciseInputs__body(i64 %intValue, double %doubleValue, %Result* %3, %String* %4) - call void @__quantum__rt__string_update_reference_count(%String* %4, i32 -1) - ret i64 %5 -} - -declare %Result* @__quantum__rt__result_get_zero() - -declare %Result* @__quantum__rt__result_get_one() - -attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/test/FullstateSimulator/qir-test-simulator.ll b/src/QirRuntime/test/FullstateSimulator/qir-test-simulator.ll deleted file mode 100644 index fd09ccb8cb8..00000000000 --- a/src/QirRuntime/test/FullstateSimulator/qir-test-simulator.ll +++ /dev/null @@ -1,1367 +0,0 @@ - -%Range = type { i64, i64, i64 } -%Tuple = type opaque -%Callable = type opaque -%Qubit = type opaque -%Array = type opaque -%Result = type opaque - -@PauliI = constant i2 0 -@PauliX = constant i2 1 -@PauliY = constant i2 -1 -@PauliZ = constant i2 -2 -@EmptyRange = internal constant %Range { i64 0, i64 1, i64 -1 } -@Microsoft__Quantum__Intrinsic__X = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__Y = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__Z = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__H = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__H__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__S = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__T = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__T__ctladj__wrapper] -@Microsoft__Quantum__Intrinsic__R = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__R__ctladj__wrapper] -@PartialApplication__1 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__ctladj__wrapper] -@MemoryManagement__1 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__1__RefCount, void (%Tuple*, i32)* @MemoryManagement__1__AliasCount] - -@Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS = alias i64 (), i64 ()* @Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS__body - -define i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %op) { -entry: - call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 1) - %res = alloca i64, align 8 - store i64 0, i64* %res, align 4 - %target = call %Qubit* @__quantum__rt__qubit_allocate() - %ctls = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) - %1 = bitcast %Tuple* %0 to { %Qubit* }* - %2 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %1, i32 0, i32 0 - store %Qubit* %target, %Qubit** %2, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %op, %Tuple* %0, %Tuple* null) - %3 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 1) - call void @__quantum__rt__callable_make_adjoint(%Callable* %3) - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { %Qubit* }* - %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 - store %Qubit* %target, %Qubit** %6, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %3, %Tuple* %4, %Tuple* null) - %7 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %target) - %8 = call %Result* @__quantum__rt__result_get_zero() - %9 = call i1 @__quantum__rt__result_equal(%Result* %7, %Result* %8) - %10 = xor i1 %9, true - br i1 %10, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - store i64 1, i64* %res, align 4 - br label %continue__1 - -else__1: ; preds = %entry - %11 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %12 = bitcast i8* %11 to %Qubit** - %qubit = load %Qubit*, %Qubit** %12, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit) - %13 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) - %14 = bitcast i8* %13 to %Qubit** - %qubit__1 = load %Qubit*, %Qubit** %14, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__1) - %15 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 1) - call void @__quantum__rt__callable_make_controlled(%Callable* %15) - %16 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) - %17 = bitcast %Tuple* %16 to { %Array*, %Qubit* }* - %18 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %17, i32 0, i32 0 - %19 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %17, i32 0, i32 1 - store %Array* %ctls, %Array** %18, align 8 - store %Qubit* %target, %Qubit** %19, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %15, %Tuple* %16, %Tuple* null) - %20 = call %Callable* @__quantum__rt__callable_copy(%Callable* %op, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %20, i32 1) - call void @__quantum__rt__callable_make_controlled(%Callable* %20) - call void @__quantum__rt__callable_make_adjoint(%Callable* %20) - %21 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) - %22 = bitcast %Tuple* %21 to { %Array*, %Qubit* }* - %23 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %22, i32 0, i32 0 - %24 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %22, i32 0, i32 1 - store %Array* %ctls, %Array** %23, align 8 - store %Qubit* %target, %Qubit** %24, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %20, %Tuple* %21, %Tuple* null) - %25 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %target) - %26 = call %Result* @__quantum__rt__result_get_zero() - %27 = call i1 @__quantum__rt__result_equal(%Result* %25, %Result* %26) - %28 = xor i1 %27, true - br i1 %28, label %then0__2, label %continue__2 - -then0__2: ; preds = %else__1 - store i64 2, i64* %res, align 4 - br label %continue__2 - -continue__2: ; preds = %then0__2, %else__1 - %29 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %30 = bitcast i8* %29 to %Qubit** - %qubit__2 = load %Qubit*, %Qubit** %30, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__2) - %31 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) - %32 = bitcast i8* %31 to %Qubit** - %qubit__3 = load %Qubit*, %Qubit** %32, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__3) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %16, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %20, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %20, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %21, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %25, i32 -1) - br label %continue__1 - -continue__1: ; preds = %continue__2, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %7, i32 -1) - call void @__quantum__rt__qubit_release(%Qubit* %target) - call void @__quantum__rt__qubit_release_array(%Array* %ctls) - %33 = load i64, i64* %res, align 4 - call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 -1) - ret i64 %33 -} - -declare void @__quantum__rt__capture_update_alias_count(%Callable*, i32) - -declare void @__quantum__rt__callable_update_alias_count(%Callable*, i32) - -declare %Qubit* @__quantum__rt__qubit_allocate() - -declare %Array* @__quantum__rt__qubit_allocate_array(i64) - -declare void @__quantum__rt__array_update_alias_count(%Array*, i32) - -declare void @__quantum__rt__callable_invoke(%Callable*, %Tuple*, %Tuple*) - -declare %Tuple* @__quantum__rt__tuple_create(i64) - -declare %Callable* @__quantum__rt__callable_copy(%Callable*, i1) - -declare void @__quantum__rt__capture_update_reference_count(%Callable*, i32) - -declare void @__quantum__rt__callable_make_adjoint(%Callable*) - -define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qubit) { -entry: - %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) - %1 = bitcast i8* %0 to i2* - %2 = load i2, i2* @PauliZ, align 1 - store i2 %2, i2* %1, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) - %qubits = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %3 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) - %4 = bitcast i8* %3 to %Qubit** - store %Qubit* %qubit, %Qubit** %4, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %5 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qubits, i32 -1) - ret %Result* %5 -} - -declare %Result* @__quantum__rt__result_get_zero() - -declare i1 @__quantum__rt__result_equal(%Result*, %Result*) - -declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) - -declare void @__quantum__qis__h__body(%Qubit*) - -declare void @__quantum__rt__callable_make_controlled(%Callable*) - -declare void @__quantum__rt__callable_update_reference_count(%Callable*, i32) - -declare void @__quantum__rt__tuple_update_reference_count(%Tuple*, i32) - -declare void @__quantum__rt__result_update_reference_count(%Result*, i32) - -declare void @__quantum__rt__qubit_release(%Qubit*) - -declare void @__quantum__rt__qubit_release_array(%Array*) - -define i64 @Microsoft__Quantum__Testing__QIR__Test_Simulator_QIS__body() #0 { -entry: - %res = alloca i64, align 8 - store i64 0, i64* %res, align 4 - %0 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__X, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %1 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %0) - store i64 %1, i64* %res, align 4 - %2 = icmp ne i64 %1, 0 - br i1 %2, label %then0__1, label %continue__1 - -then0__1: ; preds = %entry - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - ret i64 %1 - -continue__1: ; preds = %entry - %3 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Y, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %4 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %3) - store i64 %4, i64* %res, align 4 - %5 = icmp ne i64 %4, 0 - br i1 %5, label %then0__2, label %continue__2 - -then0__2: ; preds = %continue__1 - %6 = add i64 10, %4 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - ret i64 %6 - -continue__2: ; preds = %continue__1 - %7 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Z, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %8 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %7) - store i64 %8, i64* %res, align 4 - %9 = icmp ne i64 %8, 0 - br i1 %9, label %then0__3, label %continue__3 - -then0__3: ; preds = %continue__2 - %10 = add i64 20, %8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - ret i64 %10 - -continue__3: ; preds = %continue__2 - %11 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__H, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %12 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %11) - store i64 %12, i64* %res, align 4 - %13 = icmp ne i64 %12, 0 - br i1 %13, label %then0__4, label %continue__4 - -then0__4: ; preds = %continue__3 - %14 = add i64 30, %12 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - ret i64 %14 - -continue__4: ; preds = %continue__3 - %15 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__S, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %16 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %15) - store i64 %16, i64* %res, align 4 - %17 = icmp ne i64 %16, 0 - br i1 %17, label %then0__5, label %continue__5 - -then0__5: ; preds = %continue__4 - %18 = add i64 40, %16 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - ret i64 %18 - -continue__5: ; preds = %continue__4 - %19 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__T, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %20 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %19) - store i64 %20, i64* %res, align 4 - %21 = icmp ne i64 %20, 0 - br i1 %21, label %then0__6, label %continue__6 - -then0__6: ; preds = %continue__5 - %22 = add i64 50, %20 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) - ret i64 %22 - -continue__6: ; preds = %continue__5 - %23 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Callable*, i2, double }* getelementptr ({ %Callable*, i2, double }, { %Callable*, i2, double }* null, i32 1) to i64)) - %24 = bitcast %Tuple* %23 to { %Callable*, i2, double }* - %25 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 0 - %26 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 1 - %27 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %24, i32 0, i32 2 - %28 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__R, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %29 = load i2, i2* @PauliX, align 1 - store %Callable* %28, %Callable** %25, align 8 - store i2 %29, i2* %26, align 1 - store double 4.200000e-01, double* %27, align 8 - %30 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__1, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %23) - %31 = call i64 @Microsoft__Quantum__Testing__QIR__InvokeAllVariants__body(%Callable* %30) - store i64 %31, i64* %res, align 4 - %32 = icmp ne i64 %31, 0 - br i1 %32, label %then0__7, label %continue__7 - -then0__7: ; preds = %continue__6 - %33 = add i64 60, %31 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) - ret i64 %33 - -continue__7: ; preds = %continue__6 - %targets = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) - %ctls = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %paulis = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %34 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %35 = bitcast i8* %34 to i2* - %36 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %37 = bitcast i8* %36 to i2* - %38 = load i2, i2* @PauliX, align 1 - %39 = load i2, i2* @PauliY, align 1 - store i2 %38, i2* %35, align 1 - store i2 %39, i2* %37, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) - call void @__quantum__qis__exp__body(%Array* %paulis, double 4.200000e-01, %Array* %targets) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis, i32 -1) - %paulis__1 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__1, i64 0) - %41 = bitcast i8* %40 to i2* - %42 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__1, i64 1) - %43 = bitcast i8* %42 to i2* - %44 = load i2, i2* @PauliX, align 1 - %45 = load i2, i2* @PauliY, align 1 - store i2 %44, i2* %41, align 1 - store i2 %45, i2* %43, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__1, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) - call void @__quantum__qis__exp__adj(%Array* %paulis__1, double 4.200000e-01, %Array* %targets) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__1, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis__1, i32 -1) - %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %targets, i64 0) - %47 = bitcast i8* %46 to %Qubit** - %48 = load %Qubit*, %Qubit** %47, align 8 - %49 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %48) - %50 = call %Result* @__quantum__rt__result_get_zero() - %51 = call i1 @__quantum__rt__result_equal(%Result* %49, %Result* %50) - %52 = xor i1 %51, true - br i1 %52, label %then0__8, label %continue__8 - -then0__8: ; preds = %continue__7 - store i64 1, i64* %res, align 4 - br label %continue__8 - -continue__8: ; preds = %then0__8, %continue__7 - %53 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %54 = bitcast i8* %53 to %Qubit** - %qubit = load %Qubit*, %Qubit** %54, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit) - %55 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) - %56 = bitcast i8* %55 to %Qubit** - %qubit__1 = load %Qubit*, %Qubit** %56, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %paulis__2 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %57 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__2, i64 0) - %58 = bitcast i8* %57 to i2* - %59 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__2, i64 1) - %60 = bitcast i8* %59 to i2* - %61 = load i2, i2* @PauliX, align 1 - %62 = load i2, i2* @PauliY, align 1 - store i2 %61, i2* %58, align 1 - store i2 %62, i2* %60, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__2, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) - %63 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %64 = bitcast %Tuple* %63 to { %Array*, double, %Array* }* - %65 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 0 - %66 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 1 - %67 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %64, i32 0, i32 2 - store %Array* %paulis__2, %Array** %65, align 8 - store double 4.200000e-01, double* %66, align 8 - store %Array* %targets, %Array** %67, align 8 - call void @__quantum__qis__exp__ctl(%Array* %ctls, { %Array*, double, %Array* }* %64) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__2, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis__2, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %63, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %paulis__3 = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %68 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__3, i64 0) - %69 = bitcast i8* %68 to i2* - %70 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis__3, i64 1) - %71 = bitcast i8* %70 to i2* - %72 = load i2, i2* @PauliX, align 1 - %73 = load i2, i2* @PauliY, align 1 - store i2 %72, i2* %69, align 1 - store i2 %73, i2* %71, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__3, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 1) - %74 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %75 = bitcast %Tuple* %74 to { %Array*, double, %Array* }* - %76 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 0 - %77 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 1 - %78 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %75, i32 0, i32 2 - store %Array* %paulis__3, %Array** %76, align 8 - store double 4.200000e-01, double* %77, align 8 - store %Array* %targets, %Array** %78, align 8 - call void @__quantum__qis__exp__ctladj(%Array* %ctls, { %Array*, double, %Array* }* %75) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis__3, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis__3, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %74, i32 -1) - %79 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %80 = bitcast i8* %79 to %Qubit** - %qubit__2 = load %Qubit*, %Qubit** %80, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__2) - %81 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 1) - %82 = bitcast i8* %81 to %Qubit** - %qubit__3 = load %Qubit*, %Qubit** %82, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__3) - %83 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %targets, i64 0) - %84 = bitcast i8* %83 to %Qubit** - %85 = load %Qubit*, %Qubit** %84, align 8 - %86 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %85) - %87 = call %Result* @__quantum__rt__result_get_zero() - %88 = call i1 @__quantum__rt__result_equal(%Result* %86, %Result* %87) - %89 = xor i1 %88, true - br i1 %89, label %then0__9, label %continue__9 - -then0__9: ; preds = %continue__8 - store i64 2, i64* %res, align 4 - br label %continue__9 - -continue__9: ; preds = %then0__9, %continue__8 - call void @__quantum__rt__array_update_alias_count(%Array* %targets, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %49, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %86, i32 -1) - call void @__quantum__rt__qubit_release_array(%Array* %targets) - call void @__quantum__rt__qubit_release_array(%Array* %ctls) - %90 = load i64, i64* %res, align 4 - %91 = icmp ne i64 %90, 0 - br i1 %91, label %then0__10, label %continue__10 - -then0__10: ; preds = %continue__9 - %92 = add i64 70, %90 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) - ret i64 %92 - -continue__10: ; preds = %continue__9 - %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 3) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) - %93 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %94 = bitcast i8* %93 to %Qubit** - %qubit__4 = load %Qubit*, %Qubit** %94, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__4) - %95 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %96 = bitcast i8* %95 to %Qubit** - %qubit__5 = load %Qubit*, %Qubit** %96, align 8 - call void @__quantum__qis__h__body(%Qubit* %qubit__5) - %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 3) - %97 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) - %98 = bitcast i8* %97 to i2* - %99 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 1) - %100 = bitcast i8* %99 to i2* - %101 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 2) - %102 = bitcast i8* %101 to i2* - %103 = load i2, i2* @PauliX, align 1 - %104 = load i2, i2* @PauliZ, align 1 - %105 = load i2, i2* @PauliX, align 1 - store i2 %103, i2* %98, align 1 - store i2 %104, i2* %100, align 1 - store i2 %105, i2* %102, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) - %106 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qs) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) - %107 = call %Result* @__quantum__rt__result_get_zero() - %108 = call i1 @__quantum__rt__result_equal(%Result* %106, %Result* %107) - %109 = xor i1 %108, true - br i1 %109, label %then0__11, label %continue__11 - -then0__11: ; preds = %continue__10 - store i64 80, i64* %res, align 4 - br label %continue__11 - -continue__11: ; preds = %then0__11, %continue__10 - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %106, i32 -1) - call void @__quantum__rt__qubit_release_array(%Array* %qs) - %110 = load i64, i64* %res, align 4 - call void @__quantum__rt__capture_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %0, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %3, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %7, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %11, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %19, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %30, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %30, i32 -1) - ret i64 %110 -} - -define void @Microsoft__Quantum__Intrinsic__X__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -declare %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]*, [2 x void (%Tuple*, i32)*]*, %Tuple*) - -define void @Microsoft__Quantum__Intrinsic__Y__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__T__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__T__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__R__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { i2, double, %Qubit* }* - %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 - %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 - %4 = load i2, i2* %1, align 1 - %5 = load double, double* %2, align 8 - %6 = load %Qubit*, %Qubit** %3, align 8 - call void @Microsoft__Quantum__Intrinsic__R__body(i2 %4, double %5, %Qubit* %6) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__R__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { i2, double, %Qubit* }* - %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 - %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 - %4 = load i2, i2* %1, align 1 - %5 = load double, double* %2, align 8 - %6 = load %Qubit*, %Qubit** %3, align 8 - call void @Microsoft__Quantum__Intrinsic__R__adj(i2 %4, double %5, %Qubit* %6) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__R__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, { i2, double, %Qubit* }* }* - %1 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load { i2, double, %Qubit* }*, { i2, double, %Qubit* }** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__R__ctl(%Array* %3, { i2, double, %Qubit* }* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__R__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, { i2, double, %Qubit* }* }* - %1 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load { i2, double, %Qubit* }*, { i2, double, %Qubit* }** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__R__ctladj(%Array* %3, { i2, double, %Qubit* }* %4) - ret void -} - -define void @Lifted__PartialApplication__1__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 1 - %2 = load i2, i2* %1, align 1 - %3 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 2 - %4 = load double, double* %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 - %7 = load %Qubit*, %Qubit** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %9 = bitcast %Tuple* %8 to { i2, double, %Qubit* }* - %10 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 2 - store i2 %2, i2* %10, align 1 - store double %4, double* %11, align 8 - store %Qubit* %7, %Qubit** %12, align 8 - %13 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - ret void -} - -define void @Lifted__PartialApplication__1__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 1 - %2 = load i2, i2* %1, align 1 - %3 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 2 - %4 = load double, double* %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %6 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %5, i32 0, i32 0 - %7 = load %Qubit*, %Qubit** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %9 = bitcast %Tuple* %8 to { i2, double, %Qubit* }* - %10 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %9, i32 0, i32 2 - store i2 %2, i2* %10, align 1 - store double %4, double* %11, align 8 - store %Qubit* %7, %Qubit** %12, align 8 - %13 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - %15 = call %Callable* @__quantum__rt__callable_copy(%Callable* %14, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 1) - call void @__quantum__rt__callable_make_adjoint(%Callable* %15) - call void @__quantum__rt__callable_invoke(%Callable* %15, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %15, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %15, i32 -1) - ret void -} - -define void @Lifted__PartialApplication__1__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - %5 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %6 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 1 - %7 = load i2, i2* %6, align 1 - %8 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 2 - %9 = load double, double* %8, align 8 - %10 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %11 = bitcast %Tuple* %10 to { i2, double, %Qubit* }* - %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 0 - %13 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 1 - %14 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 2 - store i2 %7, i2* %12, align 1 - store double %9, double* %13, align 8 - store %Qubit* %4, %Qubit** %14, align 8 - %15 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) - %16 = bitcast %Tuple* %15 to { %Array*, { i2, double, %Qubit* }* }* - %17 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 0 - %18 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 1 - store %Array* %3, %Array** %17, align 8 - store { i2, double, %Qubit* }* %11, { i2, double, %Qubit* }** %18, align 8 - %19 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 0 - %20 = load %Callable*, %Callable** %19, align 8 - %21 = call %Callable* @__quantum__rt__callable_copy(%Callable* %20, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 1) - call void @__quantum__rt__callable_make_controlled(%Callable* %21) - call void @__quantum__rt__callable_invoke(%Callable* %21, %Tuple* %15, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %10, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %21, i32 -1) - ret void -} - -define void @Lifted__PartialApplication__1__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - %5 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %6 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 1 - %7 = load i2, i2* %6, align 1 - %8 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 2 - %9 = load double, double* %8, align 8 - %10 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %11 = bitcast %Tuple* %10 to { i2, double, %Qubit* }* - %12 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 0 - %13 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 1 - %14 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %11, i32 0, i32 2 - store i2 %7, i2* %12, align 1 - store double %9, double* %13, align 8 - store %Qubit* %4, %Qubit** %14, align 8 - %15 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) - %16 = bitcast %Tuple* %15 to { %Array*, { i2, double, %Qubit* }* }* - %17 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 0 - %18 = getelementptr inbounds { %Array*, { i2, double, %Qubit* }* }, { %Array*, { i2, double, %Qubit* }* }* %16, i32 0, i32 1 - store %Array* %3, %Array** %17, align 8 - store { i2, double, %Qubit* }* %11, { i2, double, %Qubit* }** %18, align 8 - %19 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %5, i32 0, i32 0 - %20 = load %Callable*, %Callable** %19, align 8 - %21 = call %Callable* @__quantum__rt__callable_copy(%Callable* %20, i1 false) - call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 1) - call void @__quantum__rt__callable_make_adjoint(%Callable* %21) - call void @__quantum__rt__callable_make_controlled(%Callable* %21) - call void @__quantum__rt__callable_invoke(%Callable* %21, %Tuple* %15, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %10, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %15, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %21, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %21, i32 -1) - ret void -} - -define void @MemoryManagement__1__RefCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -define void @MemoryManagement__1__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, i2, double }* - %1 = getelementptr inbounds { %Callable*, i2, double }, { %Callable*, i2, double }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -declare %Array* @__quantum__rt__array_create_1d(i32, i64) - -declare void @__quantum__qis__exp__body(%Array*, double, %Array*) - -declare void @__quantum__rt__array_update_reference_count(%Array*, i32) - -declare void @__quantum__qis__exp__adj(%Array*, double, %Array*) - -declare void @__quantum__qis__exp__ctl(%Array*, { %Array*, double, %Array* }*) - -declare void @__quantum__qis__exp__ctladj(%Array*, { %Array*, double, %Array* }*) - -declare %Result* @__quantum__qis__measure__body(%Array*, %Array*) - -define void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__s__body(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__s__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__s__adj(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__s__adj(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__s__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__s__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__s__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__s__ctladj(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Exp__body(%Array* %paulis, double %theta, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - call void @__quantum__qis__exp__body(%Array* %paulis, double %theta, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Exp__adj(%Array* %paulis, double %theta, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - call void @__quantum__qis__exp__adj(%Array* %paulis, double %theta, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Exp__ctl(%Array* %__controlQubits__, { %Array*, double, %Array* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %1 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 0 - %paulis = load %Array*, %Array** %1, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - %2 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 1 - %theta = load double, double* %2, align 8 - %3 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 2 - %qubits = load %Array*, %Array** %3, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { %Array*, double, %Array* }* - %6 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 0 - %7 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 1 - %8 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 2 - store %Array* %paulis, %Array** %6, align 8 - store double %theta, double* %7, align 8 - store %Array* %qubits, %Array** %8, align 8 - call void @__quantum__qis__exp__ctl(%Array* %__controlQubits__, { %Array*, double, %Array* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Exp__ctladj(%Array* %__controlQubits__, { %Array*, double, %Array* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %1 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 0 - %paulis = load %Array*, %Array** %1, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - %2 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 1 - %theta = load double, double* %2, align 8 - %3 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %0, i32 0, i32 2 - %qubits = load %Array*, %Array** %3, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ %Array*, double, %Array* }* getelementptr ({ %Array*, double, %Array* }, { %Array*, double, %Array* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { %Array*, double, %Array* }* - %6 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 0 - %7 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 1 - %8 = getelementptr inbounds { %Array*, double, %Array* }, { %Array*, double, %Array* }* %5, i32 0, i32 2 - store %Array* %paulis, %Array** %6, align 8 - store double %theta, double* %7, align 8 - store %Array* %qubits, %Array** %8, align 8 - call void @__quantum__qis__exp__ctladj(%Array* %__controlQubits__, { %Array*, double, %Array* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__t__body(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__t__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__T__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__t__adj(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__t__adj(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__t__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__t__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__t__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__t__ctladj(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__h__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__x__body(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__x__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__x__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__x__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__x__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__x__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__R__body(i2 %pauli, double %theta, %Qubit* %qubit) { -entry: - call void @__quantum__qis__r__body(i2 %pauli, double %theta, %Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__r__body(i2, double, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__R__adj(i2 %pauli, double %theta, %Qubit* %qubit) { -entry: - call void @__quantum__qis__r__adj(i2 %pauli, double %theta, %Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__r__adj(i2, double, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__R__ctl(%Array* %__controlQubits__, { i2, double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 - %pauli = load i2, i2* %1, align 1 - %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 - %theta = load double, double* %2, align 8 - %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 - %qubit = load %Qubit*, %Qubit** %3, align 8 - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { i2, double, %Qubit* }* - %6 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 0 - %7 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 1 - %8 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 2 - store i2 %pauli, i2* %6, align 1 - store double %theta, double* %7, align 8 - store %Qubit* %qubit, %Qubit** %8, align 8 - call void @__quantum__qis__r__ctl(%Array* %__controlQubits__, { i2, double, %Qubit* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) - ret void -} - -declare void @__quantum__qis__r__ctl(%Array*, { i2, double, %Qubit* }*) - -define void @Microsoft__Quantum__Intrinsic__R__ctladj(%Array* %__controlQubits__, { i2, double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %1 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 0 - %pauli = load i2, i2* %1, align 1 - %2 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 1 - %theta = load double, double* %2, align 8 - %3 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %0, i32 0, i32 2 - %qubit = load %Qubit*, %Qubit** %3, align 8 - %4 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint ({ i2, double, %Qubit* }* getelementptr ({ i2, double, %Qubit* }, { i2, double, %Qubit* }* null, i32 1) to i64)) - %5 = bitcast %Tuple* %4 to { i2, double, %Qubit* }* - %6 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 0 - %7 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 1 - %8 = getelementptr inbounds { i2, double, %Qubit* }, { i2, double, %Qubit* }* %5, i32 0, i32 2 - store i2 %pauli, i2* %6, align 1 - store double %theta, double* %7, align 8 - store %Qubit* %qubit, %Qubit** %8, align 8 - call void @__quantum__qis__r__ctladj(%Array* %__controlQubits__, { i2, double, %Qubit* }* %5) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %4, i32 -1) - ret void -} - -declare void @__quantum__qis__r__ctladj(%Array*, { i2, double, %Qubit* }*) - -define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %bases, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -define void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__z__body(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__z__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__z__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__z__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__z__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__y__body(%Qubit* %qubit) - ret void -} - -declare void @__quantum__qis__y__body(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__y__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__qis__y__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__y__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__rt__tuple_update_alias_count(%Tuple*, i32) - -attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/test/QIR-dynamic/qir-test-random.ll b/src/QirRuntime/test/QIR-dynamic/qir-test-random.ll deleted file mode 100644 index 5cca945317a..00000000000 --- a/src/QirRuntime/test/QIR-dynamic/qir-test-random.ll +++ /dev/null @@ -1,142 +0,0 @@ - -%Range = type { i64, i64, i64 } -%Qubit = type opaque -%Result = type opaque -%Array = type opaque - -@PauliI = constant i2 0 -@PauliX = constant i2 1 -@PauliY = constant i2 -1 -@PauliZ = constant i2 -2 -@EmptyRange = internal constant %Range { i64 0, i64 1, i64 -1 } - -@Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator = alias i64 (), i64 ()* @Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator__body - -define i64 @Microsoft__Quantum__Testing__QIR__QuantumRandomNumberGenerator__body() #0 { -entry: - %randomNumber = alloca i64, align 8 - store i64 0, i64* %randomNumber, align 4 - br label %header__1 - -header__1: ; preds = %exiting__1, %entry - %i = phi i64 [ 1, %entry ], [ %8, %exiting__1 ] - %0 = icmp sle i64 %i, 64 - br i1 %0, label %body__1, label %exit__1 - -body__1: ; preds = %header__1 - %q = call %Qubit* @__quantum__rt__qubit_allocate() - call void @__quantum__qis__h__body(%Qubit* %q) - %1 = load i64, i64* %randomNumber, align 4 - %2 = shl i64 %1, 1 - store i64 %2, i64* %randomNumber, align 4 - %3 = call %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %q) - %4 = call %Result* @__quantum__rt__result_get_one() - %5 = call i1 @__quantum__rt__result_equal(%Result* %3, %Result* %4) - br i1 %5, label %then0__1, label %continue__1 - -then0__1: ; preds = %body__1 - %6 = load i64, i64* %randomNumber, align 4 - %7 = add i64 %6, 1 - store i64 %7, i64* %randomNumber, align 4 - br label %continue__1 - -continue__1: ; preds = %then0__1, %body__1 - call void @__quantum__rt__result_update_reference_count(%Result* %3, i32 -1) - call void @__quantum__rt__qubit_release(%Qubit* %q) - br label %exiting__1 - -exiting__1: ; preds = %continue__1 - %8 = add i64 %i, 1 - br label %header__1 - -exit__1: ; preds = %header__1 - %9 = load i64, i64* %randomNumber, align 4 - ret i64 %9 -} - -declare %Qubit* @__quantum__rt__qubit_allocate() - -declare %Array* @__quantum__rt__qubit_allocate_array(i64) - -declare void @__quantum__qis__h__body(%Qubit*) - -define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qubit) { -entry: - %bases = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %bases, i64 0) - %1 = bitcast i8* %0 to i2* - %2 = load i2, i2* @PauliZ, align 1 - store i2 %2, i2* %1, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) - %qubits = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %3 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) - %4 = bitcast i8* %3 to %Qubit** - store %Qubit* %qubit, %Qubit** %4, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %5 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qubits, i32 -1) - ret %Result* %5 -} - -declare %Result* @__quantum__rt__result_get_one() - -declare i1 @__quantum__rt__result_equal(%Result*, %Result*) - -declare void @__quantum__rt__result_update_reference_count(%Result*, i32) - -declare void @__quantum__rt__qubit_release(%Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qubit) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qubit) { -entry: - call void @__quantum__qis__h__body(%Qubit* %qubit) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -declare void @__quantum__rt__array_update_alias_count(%Array*, i32) - -declare void @__quantum__qis__h__ctl(%Array*, %Qubit*) - -define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qubit) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__h__ctl(%Array* %__controlQubits__, %Qubit* %qubit) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %bases, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__measure__body(%Array* %bases, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %bases, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -declare %Result* @__quantum__qis__measure__body(%Array*, %Array*) - -declare %Array* @__quantum__rt__array_create_1d(i32, i64) - -declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) - -declare void @__quantum__rt__array_update_reference_count(%Array*, i32) - -attributes #0 = { "EntryPoint" } diff --git a/src/QirRuntime/test/QIR-tracer/tracer-qir.ll b/src/QirRuntime/test/QIR-tracer/tracer-qir.ll deleted file mode 100644 index 0bf147d470f..00000000000 --- a/src/QirRuntime/test/QIR-tracer/tracer-qir.ll +++ /dev/null @@ -1,2080 +0,0 @@ - -%Range = type { i64, i64, i64 } -%Tuple = type opaque -%Result = type opaque -%Qubit = type opaque -%Array = type opaque -%Callable = type opaque -%String = type opaque - -@PauliI = constant i2 0 -@PauliX = constant i2 1 -@PauliY = constant i2 -1 -@PauliZ = constant i2 -2 -@EmptyRange = internal constant %Range { i64 0, i64 1, i64 -1 } -@Microsoft__Quantum__Testing__Tracer__Delay = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Testing__Tracer__Delay__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@Microsoft__Quantum__Intrinsic__X = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper] -@PartialApplication__1 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__1__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@MemoryManagement__1 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__1__RefCount, void (%Tuple*, i32)* @MemoryManagement__1__AliasCount] -@Microsoft__Quantum__Intrinsic__Y = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper] -@PartialApplication__2 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__2__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@Microsoft__Quantum__Intrinsic__Z = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper] -@PartialApplication__3 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__3__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@Microsoft__Quantum__Intrinsic__S = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__adj__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctl__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper] -@PartialApplication__4 = constant [4 x void (%Tuple*, %Tuple*, %Tuple*)*] [void (%Tuple*, %Tuple*, %Tuple*)* @Lifted__PartialApplication__4__body__wrapper, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null, void (%Tuple*, %Tuple*, %Tuple*)* null] -@MemoryManagement__2 = constant [2 x void (%Tuple*, i32)*] [void (%Tuple*, i32)* @MemoryManagement__2__RefCount, void (%Tuple*, i32)* @MemoryManagement__2__AliasCount] - -define %Result* @Microsoft__Quantum__Instructions__Mx__body(%Qubit* %qb) { -entry: - %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb) - ret %Result* %0 -} - -declare %Result* @__quantum__qis__single_qubit_measure(i64, i64, %Qubit*) - -define %Result* @Microsoft__Quantum__Instructions__Mxx__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -declare void @__quantum__rt__array_update_alias_count(%Array*, i32) - -declare %Result* @__quantum__qis__joint_measure(i64, i64, %Array*) - -define %Result* @Microsoft__Quantum__Instructions__Mxz__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mz__body(%Qubit* %qb) { -entry: - %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mzx__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Instructions__Mzz__body(%Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %0 -} - -define void @Microsoft__Quantum__Instructions__Sx__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) - ret void -} - -declare void @__quantum__qis__single_qubit_op(i64, i64, %Qubit*) - -define void @Microsoft__Quantum__Instructions__Sx__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 17, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sx__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -declare void @__quantum__qis__single_qubit_op_ctl(i64, i64, %Array*, %Qubit*) - -define void @Microsoft__Quantum__Instructions__Sx__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 18, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Sz__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 13, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tx__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 14, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Instructions__Tz__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__ApplyConditionallyIntrinsic__body(%Array* %measurementResults, %Array* %resultsValues, %Callable* %onEqualOp, %Callable* %onNonEqualOp) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i32 1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onEqualOp, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i32 1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onNonEqualOp, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i32 1) - call void @__quantum__qis__apply_conditionally(%Array* %measurementResults, %Array* %resultsValues, %Callable* %onEqualOp, %Callable* %onNonEqualOp) - call void @__quantum__rt__array_update_alias_count(%Array* %measurementResults, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %resultsValues, i32 -1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onEqualOp, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onEqualOp, i32 -1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onNonEqualOp, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onNonEqualOp, i32 -1) - ret void -} - -declare void @__quantum__rt__capture_update_alias_count(%Callable*, i32) - -declare void @__quantum__rt__callable_update_alias_count(%Callable*, i32) - -declare void @__quantum__qis__apply_conditionally(%Array*, %Array*, %Callable*, %Callable*) - -define void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %measurementResult, %Callable* %onResultZeroOp, %Callable* %onResultOneOp) { -entry: - call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultZeroOp, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i32 1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultOneOp, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i32 1) - %0 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %1 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %0, i64 0) - %2 = bitcast i8* %1 to %Result** - store %Result* %measurementResult, %Result** %2, align 8 - %3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 0) - %5 = bitcast i8* %4 to %Result** - %6 = call %Result* @__quantum__rt__result_get_zero() - store %Result* %6, %Result** %5, align 8 - call void @__quantum__qis__apply_conditionally(%Array* %0, %Array* %3, %Callable* %onResultZeroOp, %Callable* %onResultOneOp) - call void @__quantum__rt__result_update_reference_count(%Result* %measurementResult, i32 1) - call void @__quantum__rt__result_update_reference_count(%Result* %6, i32 1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultZeroOp, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultZeroOp, i32 -1) - call void @__quantum__rt__capture_update_alias_count(%Callable* %onResultOneOp, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %onResultOneOp, i32 -1) - br label %header__1 - -header__1: ; preds = %exiting__1, %entry - %7 = phi i64 [ 0, %entry ], [ %12, %exiting__1 ] - %8 = icmp sle i64 %7, 0 - br i1 %8, label %body__1, label %exit__1 - -body__1: ; preds = %header__1 - %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %0, i64 %7) - %10 = bitcast i8* %9 to %Result** - %11 = load %Result*, %Result** %10, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %11, i32 -1) - br label %exiting__1 - -exiting__1: ; preds = %body__1 - %12 = add i64 %7, 1 - br label %header__1 - -exit__1: ; preds = %header__1 - call void @__quantum__rt__array_update_reference_count(%Array* %0, i32 -1) - br label %header__2 - -header__2: ; preds = %exiting__2, %exit__1 - %13 = phi i64 [ 0, %exit__1 ], [ %18, %exiting__2 ] - %14 = icmp sle i64 %13, 0 - br i1 %14, label %body__2, label %exit__2 - -body__2: ; preds = %header__2 - %15 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 %13) - %16 = bitcast i8* %15 to %Result** - %17 = load %Result*, %Result** %16, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 -1) - br label %exiting__2 - -exiting__2: ; preds = %body__2 - %18 = add i64 %13, 1 - br label %header__2 - -exit__2: ; preds = %header__2 - call void @__quantum__rt__array_update_reference_count(%Array* %3, i32 -1) - ret void -} - -declare %Array* @__quantum__rt__array_create_1d(i32, i64) - -declare i8* @__quantum__rt__array_get_element_ptr_1d(%Array*, i64) - -declare %Result* @__quantum__rt__result_get_zero() - -declare void @__quantum__rt__result_update_reference_count(%Result*, i32) - -declare void @__quantum__rt__array_update_reference_count(%Array*, i32) - -define void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %control, %Qubit* %target) { -entry: - %ctls = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %1 = bitcast i8* %0 to %Qubit** - store %Qubit* %control, %Qubit** %1, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - br i1 true, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %ctls, %Qubit* %target) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %ctls, %Qubit* %target) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__CNOT__adj(%Qubit* %control, %Qubit* %target) { -entry: - call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %control, %Qubit* %target) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__CNOT__ctl(%Array* %ctls, { %Qubit*, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 0 - %control = load %Qubit*, %Qubit** %1, align 8 - %2 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 1 - %target = load %Qubit*, %Qubit** %2, align 8 - %3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %3, i64 0) - %5 = bitcast i8* %4 to %Qubit** - store %Qubit* %control, %Qubit** %5, align 8 - %ctls__1 = call %Array* @__quantum__rt__array_concatenate(%Array* %ctls, %Array* %3) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 1) - %6 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls__1) - %7 = icmp eq i64 %6, 1 - br i1 %7, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %ctls__1, %Qubit* %target) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %ctls__1, %Qubit* %target) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %3, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -declare %Array* @__quantum__rt__array_concatenate(%Array*, %Array*) - -declare i64 @__quantum__rt__array_get_size_1d(%Array*) - -define void @Microsoft__Quantum__Intrinsic__CNOT__ctladj(%Array* %__controlQubits__, { %Qubit*, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %1 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 0 - %control = load %Qubit*, %Qubit** %1, align 8 - %2 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %0, i32 0, i32 1 - %target = load %Qubit*, %Qubit** %2, align 8 - %3 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2)) - %4 = bitcast %Tuple* %3 to { %Qubit*, %Qubit* }* - %5 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %4, i32 0, i32 0 - %6 = getelementptr inbounds { %Qubit*, %Qubit* }, { %Qubit*, %Qubit* }* %4, i32 0, i32 1 - store %Qubit* %control, %Qubit** %5, align 8 - store %Qubit* %target, %Qubit** %6, align 8 - call void @Microsoft__Quantum__Intrinsic__CNOT__ctl(%Array* %__controlQubits__, { %Qubit*, %Qubit* }* %4) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %3, i32 -1) - ret void -} - -declare %Tuple* @__quantum__rt__tuple_create(i64) - -declare void @__quantum__rt__tuple_update_reference_count(%Tuple*, i32) - -define void @Microsoft__Quantum__Intrinsic__H__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__H__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define %Result* @Microsoft__Quantum__Intrinsic__M__body(%Qubit* %qb) { -entry: - %0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb) - ret %Result* %0 -} - -define %Result* @Microsoft__Quantum__Intrinsic__Measure__body(%Array* %paulis, %Array* %qubits) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %0 = call %Result* @__quantum__rt__result_get_one() - %res = alloca %Result*, align 8 - store %Result* %0, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %0, i32 1) - %haveY = alloca i1, align 1 - store i1 false, i1* %haveY, align 1 - %1 = call i64 @__quantum__rt__array_get_size_1d(%Array* %paulis) - %2 = sub i64 %1, 1 - br label %header__1 - -header__1: ; preds = %exiting__1, %entry - %i = phi i64 [ 0, %entry ], [ %15, %exiting__1 ] - %3 = icmp sle i64 %i, %2 - br i1 %3, label %body__1, label %exit__1 - -body__1: ; preds = %header__1 - %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) - %5 = bitcast i8* %4 to i2* - %6 = load i2, i2* %5, align 1 - %7 = load i2, i2* @PauliY, align 1 - %8 = icmp eq i2 %6, %7 - br i1 %8, label %condContinue__1, label %condFalse__1 - -condFalse__1: ; preds = %body__1 - %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) - %10 = bitcast i8* %9 to i2* - %11 = load i2, i2* %10, align 1 - %12 = load i2, i2* @PauliI, align 1 - %13 = icmp eq i2 %11, %12 - br label %condContinue__1 - -condContinue__1: ; preds = %condFalse__1, %body__1 - %14 = phi i1 [ %8, %body__1 ], [ %13, %condFalse__1 ] - br i1 %14, label %then0__1, label %continue__1 - -then0__1: ; preds = %condContinue__1 - store i1 true, i1* %haveY, align 1 - br label %continue__1 - -continue__1: ; preds = %then0__1, %condContinue__1 - br label %exiting__1 - -exiting__1: ; preds = %continue__1 - %15 = add i64 %i, 1 - br label %header__1 - -exit__1: ; preds = %header__1 - %16 = load i1, i1* %haveY, align 1 - br i1 %16, label %then0__2, label %test1__1 - -then0__2: ; preds = %exit__1 - %17 = call %Result* @__quantum__qis__joint_measure(i64 106, i64 1, %Array* %qubits) - call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 1) - store %Result* %17, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %17, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %0, i32 -1) - br label %continue__2 - -test1__1: ; preds = %exit__1 - %18 = icmp sgt i64 %1, 2 - br i1 %18, label %then1__1, label %test2__1 - -then1__1: ; preds = %test1__1 - %19 = call %Result* @__quantum__qis__joint_measure(i64 107, i64 1, %Array* %qubits) - call void @__quantum__rt__result_update_reference_count(%Result* %19, i32 1) - %20 = load %Result*, %Result** %res, align 8 - store %Result* %19, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %19, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %20, i32 -1) - br label %continue__2 - -test2__1: ; preds = %test1__1 - %21 = icmp eq i64 %1, 1 - br i1 %21, label %then2__1, label %test3__1 - -then2__1: ; preds = %test2__1 - %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %23 = bitcast i8* %22 to i2* - %24 = load i2, i2* %23, align 1 - %25 = load i2, i2* @PauliX, align 1 - %26 = icmp eq i2 %24, %25 - br i1 %26, label %then0__3, label %else__1 - -then0__3: ; preds = %then2__1 - %27 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) - %28 = bitcast i8* %27 to %Qubit** - %qb = load %Qubit*, %Qubit** %28, align 8 - %29 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb) - call void @__quantum__rt__result_update_reference_count(%Result* %29, i32 1) - %30 = load %Result*, %Result** %res, align 8 - store %Result* %29, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %29, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %30, i32 -1) - br label %continue__3 - -else__1: ; preds = %then2__1 - %31 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qubits, i64 0) - %32 = bitcast i8* %31 to %Qubit** - %qb__1 = load %Qubit*, %Qubit** %32, align 8 - %33 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__1) - call void @__quantum__rt__result_update_reference_count(%Result* %33, i32 1) - %34 = load %Result*, %Result** %res, align 8 - store %Result* %33, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %33, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %34, i32 -1) - br label %continue__3 - -continue__3: ; preds = %else__1, %then0__3 - br label %continue__2 - -test3__1: ; preds = %test2__1 - %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %36 = bitcast i8* %35 to i2* - %37 = load i2, i2* %36, align 1 - %38 = load i2, i2* @PauliX, align 1 - %39 = icmp eq i2 %37, %38 - br i1 %39, label %condTrue__1, label %condContinue__2 - -condTrue__1: ; preds = %test3__1 - %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %41 = bitcast i8* %40 to i2* - %42 = load i2, i2* %41, align 1 - %43 = load i2, i2* @PauliX, align 1 - %44 = icmp eq i2 %42, %43 - br label %condContinue__2 - -condContinue__2: ; preds = %condTrue__1, %test3__1 - %45 = phi i1 [ %44, %condTrue__1 ], [ %39, %test3__1 ] - br i1 %45, label %then3__1, label %test4__1 - -then3__1: ; preds = %condContinue__2 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %46 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %46, i32 1) - %47 = load %Result*, %Result** %res, align 8 - store %Result* %46, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %46, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %47, i32 -1) - br label %continue__2 - -test4__1: ; preds = %condContinue__2 - %48 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %49 = bitcast i8* %48 to i2* - %50 = load i2, i2* %49, align 1 - %51 = load i2, i2* @PauliX, align 1 - %52 = icmp eq i2 %50, %51 - br i1 %52, label %condTrue__2, label %condContinue__3 - -condTrue__2: ; preds = %test4__1 - %53 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %54 = bitcast i8* %53 to i2* - %55 = load i2, i2* %54, align 1 - %56 = load i2, i2* @PauliZ, align 1 - %57 = icmp eq i2 %55, %56 - br label %condContinue__3 - -condContinue__3: ; preds = %condTrue__2, %test4__1 - %58 = phi i1 [ %57, %condTrue__2 ], [ %52, %test4__1 ] - br i1 %58, label %then4__1, label %test5__1 - -then4__1: ; preds = %condContinue__3 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %59 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %59, i32 1) - %60 = load %Result*, %Result** %res, align 8 - store %Result* %59, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %59, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %60, i32 -1) - br label %continue__2 - -test5__1: ; preds = %condContinue__3 - %61 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %62 = bitcast i8* %61 to i2* - %63 = load i2, i2* %62, align 1 - %64 = load i2, i2* @PauliZ, align 1 - %65 = icmp eq i2 %63, %64 - br i1 %65, label %condTrue__3, label %condContinue__4 - -condTrue__3: ; preds = %test5__1 - %66 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %67 = bitcast i8* %66 to i2* - %68 = load i2, i2* %67, align 1 - %69 = load i2, i2* @PauliX, align 1 - %70 = icmp eq i2 %68, %69 - br label %condContinue__4 - -condContinue__4: ; preds = %condTrue__3, %test5__1 - %71 = phi i1 [ %70, %condTrue__3 ], [ %65, %test5__1 ] - br i1 %71, label %then5__1, label %test6__1 - -then5__1: ; preds = %condContinue__4 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %72 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %72, i32 1) - %73 = load %Result*, %Result** %res, align 8 - store %Result* %72, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %72, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %73, i32 -1) - br label %continue__2 - -test6__1: ; preds = %condContinue__4 - %74 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %75 = bitcast i8* %74 to i2* - %76 = load i2, i2* %75, align 1 - %77 = load i2, i2* @PauliZ, align 1 - %78 = icmp eq i2 %76, %77 - br i1 %78, label %condTrue__4, label %condContinue__5 - -condTrue__4: ; preds = %test6__1 - %79 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %80 = bitcast i8* %79 to i2* - %81 = load i2, i2* %80, align 1 - %82 = load i2, i2* @PauliZ, align 1 - %83 = icmp eq i2 %81, %82 - br label %condContinue__5 - -condContinue__5: ; preds = %condTrue__4, %test6__1 - %84 = phi i1 [ %83, %condTrue__4 ], [ %78, %test6__1 ] - br i1 %84, label %then6__1, label %continue__2 - -then6__1: ; preds = %condContinue__5 - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 1) - %85 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qubits) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %85, i32 1) - %86 = load %Result*, %Result** %res, align 8 - store %Result* %85, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %85, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %86, i32 -1) - br label %continue__2 - -continue__2: ; preds = %then6__1, %condContinue__5, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 - %87 = load %Result*, %Result** %res, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qubits, i32 -1) - ret %Result* %87 -} - -declare %Result* @__quantum__rt__result_get_one() - -define void @Microsoft__Quantum__Intrinsic__Rx__body(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rx__adj(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rx__ctl(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rx__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Ry__body(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Ry__adj(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Ry__ctl(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Ry__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rz__body(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rz__adj(double %theta, %Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rz__ctl(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Rz__ctladj(%Array* %ctls, { double, %Qubit* }* %0) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %1 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 0 - %theta = load double, double* %1, align 8 - %2 = getelementptr inbounds { double, %Qubit* }, { double, %Qubit* }* %0, i32 0, i32 1 - %qb = load %Qubit*, %Qubit** %2, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__T__ctladj(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls, %Qubit* %qb) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 4, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 5, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 4, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 5, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %qb) { -entry: - call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %ctls, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %ctls) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 7, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 8, i64 1, %Array* %ctls, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %__controlQubits__, %Qubit* %qb) { -entry: - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 1) - %0 = call i64 @__quantum__rt__array_get_size_1d(%Array* %__controlQubits__) - %1 = icmp eq i64 %0, 1 - br i1 %1, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 7, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 8, i64 1, %Array* %__controlQubits__, %Qubit* %qb) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %__controlQubits__, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Testing__Tracer__Delay__body(%Callable* %op, %Qubit* %arg, %Tuple* %aux) { -entry: - call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 1) - %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) - %1 = bitcast %Tuple* %0 to { %Qubit* }* - %2 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %1, i32 0, i32 0 - store %Qubit* %arg, %Qubit** %2, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %op, %Tuple* %0, %Tuple* null) - call void @__quantum__rt__capture_update_alias_count(%Callable* %op, i32 -1) - call void @__quantum__rt__callable_update_alias_count(%Callable* %op, i32 -1) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %0, i32 -1) - ret void -} - -declare void @__quantum__rt__callable_invoke(%Callable*, %Tuple*, %Tuple*) - -define void @Microsoft__Quantum__Testing__Tracer__TestCoreIntrinsics__body() { -entry: - %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 3) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %1 = bitcast i8* %0 to %Qubit** - %qb = load %Qubit*, %Qubit** %1, align 8 - call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb) - %2 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %3 = bitcast i8* %2 to %Qubit** - %qb__1 = load %Qubit*, %Qubit** %3, align 8 - call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb__1) - %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %5 = bitcast i8* %4 to %Qubit** - %qb__2 = load %Qubit*, %Qubit** %5, align 8 - call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb__2) - %6 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %7 = bitcast i8* %6 to %Qubit** - %qb__3 = load %Qubit*, %Qubit** %7, align 8 - call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb__3) - %8 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %9 = bitcast i8* %8 to %Qubit** - %10 = load %Qubit*, %Qubit** %9, align 8 - %11 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %12 = bitcast i8* %11 to %Qubit** - %13 = load %Qubit*, %Qubit** %12, align 8 - call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %10, %Qubit* %13) - %14 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %15 = bitcast i8* %14 to %Qubit** - %qb__4 = load %Qubit*, %Qubit** %15, align 8 - call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__4) - %16 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %17 = bitcast i8* %16 to %Qubit** - %qb__5 = load %Qubit*, %Qubit** %17, align 8 - call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb__5) - %18 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %19 = bitcast i8* %18 to %Qubit** - %qb__6 = load %Qubit*, %Qubit** %19, align 8 - call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb__6) - %20 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %21 = bitcast i8* %20 to %Qubit** - %qb__7 = load %Qubit*, %Qubit** %21, align 8 - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb__7) - %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %23 = bitcast i8* %22 to %Qubit** - %qb__9 = load %Qubit*, %Qubit** %23, align 8 - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__9) - call void @__quantum__qis__inject_barrier(i64 42, i64 0) - %24 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %25 = bitcast i8* %24 to %Qubit** - %qb__11 = load %Qubit*, %Qubit** %25, align 8 - call void @__quantum__qis__single_qubit_op(i64 0, i64 1, %Qubit* %qb__11) - %26 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %27 = bitcast i8* %26 to %Qubit** - %qb__13 = load %Qubit*, %Qubit** %27, align 8 - call void @__quantum__qis__single_qubit_op(i64 3, i64 1, %Qubit* %qb__13) - %28 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %29 = bitcast i8* %28 to %Qubit** - %qb__15 = load %Qubit*, %Qubit** %29, align 8 - call void @__quantum__qis__single_qubit_op(i64 6, i64 1, %Qubit* %qb__15) - %30 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %31 = bitcast i8* %30 to %Qubit** - %qb__17 = load %Qubit*, %Qubit** %31, align 8 - call void @__quantum__qis__single_qubit_op(i64 9, i64 1, %Qubit* %qb__17) - %32 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %33 = bitcast i8* %32 to %Qubit** - %34 = load %Qubit*, %Qubit** %33, align 8 - %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %36 = bitcast i8* %35 to %Qubit** - %37 = load %Qubit*, %Qubit** %36, align 8 - call void @Microsoft__Quantum__Intrinsic__CNOT__adj(%Qubit* %34, %Qubit* %37) - %38 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %39 = bitcast i8* %38 to %Qubit** - %qb__19 = load %Qubit*, %Qubit** %39, align 8 - call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__19) - %40 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %41 = bitcast i8* %40 to %Qubit** - %qb__20 = load %Qubit*, %Qubit** %41, align 8 - call void @__quantum__qis__single_qubit_op(i64 21, i64 1, %Qubit* %qb__20) - %42 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %43 = bitcast i8* %42 to %Qubit** - %qb__21 = load %Qubit*, %Qubit** %43, align 8 - call void @__quantum__qis__single_qubit_op(i64 23, i64 1, %Qubit* %qb__21) - %44 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %45 = bitcast i8* %44 to %Qubit** - %qb__22 = load %Qubit*, %Qubit** %45, align 8 - call void @__quantum__qis__single_qubit_op(i64 15, i64 1, %Qubit* %qb__22) - %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %47 = bitcast i8* %46 to %Qubit** - %qb__24 = load %Qubit*, %Qubit** %47, align 8 - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__24) - %c = call %Qubit* @__quantum__rt__qubit_allocate() - %ctls = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %48 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls, i64 0) - %49 = bitcast i8* %48 to %Qubit** - store %Qubit* %c, %Qubit** %49, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 1) - %50 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %51 = bitcast i8* %50 to %Qubit** - %qb__26 = load %Qubit*, %Qubit** %51, align 8 - br i1 true, label %then0__1, label %else__1 - -then0__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %ctls, %Qubit* %qb__26) - br label %continue__1 - -else__1: ; preds = %entry - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %ctls, %Qubit* %qb__26) - br label %continue__1 - -continue__1: ; preds = %else__1, %then0__1 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls, i32 -1) - %ctls__1 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %52 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__1, i64 0) - %53 = bitcast i8* %52 to %Qubit** - store %Qubit* %c, %Qubit** %53, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 1) - %54 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %55 = bitcast i8* %54 to %Qubit** - %qb__27 = load %Qubit*, %Qubit** %55, align 8 - br i1 true, label %then0__2, label %else__2 - -then0__2: ; preds = %continue__1 - call void @__quantum__qis__single_qubit_op_ctl(i64 4, i64 1, %Array* %ctls__1, %Qubit* %qb__27) - br label %continue__2 - -else__2: ; preds = %continue__1 - call void @__quantum__qis__single_qubit_op_ctl(i64 5, i64 1, %Array* %ctls__1, %Qubit* %qb__27) - br label %continue__2 - -continue__2: ; preds = %else__2, %then0__2 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__1, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__1, i32 -1) - %ctls__2 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %56 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__2, i64 0) - %57 = bitcast i8* %56 to %Qubit** - store %Qubit* %c, %Qubit** %57, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i32 1) - %58 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %59 = bitcast i8* %58 to %Qubit** - %qb__28 = load %Qubit*, %Qubit** %59, align 8 - br i1 true, label %then0__3, label %else__3 - -then0__3: ; preds = %continue__2 - call void @__quantum__qis__single_qubit_op_ctl(i64 7, i64 1, %Array* %ctls__2, %Qubit* %qb__28) - br label %continue__3 - -else__3: ; preds = %continue__2 - call void @__quantum__qis__single_qubit_op_ctl(i64 8, i64 1, %Array* %ctls__2, %Qubit* %qb__28) - br label %continue__3 - -continue__3: ; preds = %else__3, %then0__3 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__2, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__2, i32 -1) - %ctls__3 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %60 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__3, i64 0) - %61 = bitcast i8* %60 to %Qubit** - store %Qubit* %c, %Qubit** %61, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i32 1) - %62 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %63 = bitcast i8* %62 to %Qubit** - %qb__29 = load %Qubit*, %Qubit** %63, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %ctls__3, %Qubit* %qb__29) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__3, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__3, i32 -1) - %ctls__4 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %64 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__4, i64 0) - %65 = bitcast i8* %64 to %Qubit** - store %Qubit* %c, %Qubit** %65, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i32 1) - %66 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %67 = bitcast i8* %66 to %Qubit** - %qb__30 = load %Qubit*, %Qubit** %67, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %ctls__4, %Qubit* %qb__30) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__4, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__4, i32 -1) - %ctls__5 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %68 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__5, i64 0) - %69 = bitcast i8* %68 to %Qubit** - store %Qubit* %c, %Qubit** %69, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i32 1) - %70 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %71 = bitcast i8* %70 to %Qubit** - %qb__31 = load %Qubit*, %Qubit** %71, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %ctls__5, %Qubit* %qb__31) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__5, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__5, i32 -1) - %ctls__6 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %72 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__6, i64 0) - %73 = bitcast i8* %72 to %Qubit** - store %Qubit* %c, %Qubit** %73, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i32 1) - %74 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %75 = bitcast i8* %74 to %Qubit** - %qb__32 = load %Qubit*, %Qubit** %75, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %ctls__6, %Qubit* %qb__32) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__6, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__6, i32 -1) - %ctls__7 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %76 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__7, i64 0) - %77 = bitcast i8* %76 to %Qubit** - store %Qubit* %c, %Qubit** %77, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 1) - %78 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %79 = bitcast i8* %78 to %Qubit** - %qb__33 = load %Qubit*, %Qubit** %79, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %ctls__7, %Qubit* %qb__33) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__7, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__7, i32 -1) - %ctls__9 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 1) - %80 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %ctls__9, i64 0) - %81 = bitcast i8* %80 to %Qubit** - store %Qubit* %c, %Qubit** %81, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 1) - %82 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %83 = bitcast i8* %82 to %Qubit** - %qb__35 = load %Qubit*, %Qubit** %83, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %ctls__9, %Qubit* %qb__35) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %ctls__9, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %ctls__9, i32 -1) - call void @__quantum__rt__qubit_release(%Qubit* %c) - %cc = call %Array* @__quantum__rt__qubit_allocate_array(i64 2) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %84 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %85 = bitcast i8* %84 to %Qubit** - %qb__37 = load %Qubit*, %Qubit** %85, align 8 - %86 = call i64 @__quantum__rt__array_get_size_1d(%Array* %cc) - %87 = icmp eq i64 %86, 1 - br i1 %87, label %then0__4, label %else__4 - -then0__4: ; preds = %continue__3 - call void @__quantum__qis__single_qubit_op_ctl(i64 1, i64 1, %Array* %cc, %Qubit* %qb__37) - br label %continue__4 - -else__4: ; preds = %continue__3 - call void @__quantum__qis__single_qubit_op_ctl(i64 2, i64 1, %Array* %cc, %Qubit* %qb__37) - br label %continue__4 - -continue__4: ; preds = %else__4, %then0__4 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %88 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %89 = bitcast i8* %88 to %Qubit** - %qb__38 = load %Qubit*, %Qubit** %89, align 8 - %90 = icmp eq i64 %86, 1 - br i1 %90, label %then0__5, label %else__5 - -then0__5: ; preds = %continue__4 - call void @__quantum__qis__single_qubit_op_ctl(i64 4, i64 1, %Array* %cc, %Qubit* %qb__38) - br label %continue__5 - -else__5: ; preds = %continue__4 - call void @__quantum__qis__single_qubit_op_ctl(i64 5, i64 1, %Array* %cc, %Qubit* %qb__38) - br label %continue__5 - -continue__5: ; preds = %else__5, %then0__5 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %91 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %92 = bitcast i8* %91 to %Qubit** - %qb__39 = load %Qubit*, %Qubit** %92, align 8 - %93 = icmp eq i64 %86, 1 - br i1 %93, label %then0__6, label %else__6 - -then0__6: ; preds = %continue__5 - call void @__quantum__qis__single_qubit_op_ctl(i64 7, i64 1, %Array* %cc, %Qubit* %qb__39) - br label %continue__6 - -else__6: ; preds = %continue__5 - call void @__quantum__qis__single_qubit_op_ctl(i64 8, i64 1, %Array* %cc, %Qubit* %qb__39) - br label %continue__6 - -continue__6: ; preds = %else__6, %then0__6 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %94 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %95 = bitcast i8* %94 to %Qubit** - %qb__40 = load %Qubit*, %Qubit** %95, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 10, i64 1, %Array* %cc, %Qubit* %qb__40) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %96 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %97 = bitcast i8* %96 to %Qubit** - %qb__41 = load %Qubit*, %Qubit** %97, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 20, i64 1, %Array* %cc, %Qubit* %qb__41) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %98 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %99 = bitcast i8* %98 to %Qubit** - %qb__42 = load %Qubit*, %Qubit** %99, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 22, i64 1, %Array* %cc, %Qubit* %qb__42) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %100 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %101 = bitcast i8* %100 to %Qubit** - %qb__43 = load %Qubit*, %Qubit** %101, align 8 - call void @__quantum__qis__single_qubit_op_ctl(i64 24, i64 1, %Array* %cc, %Qubit* %qb__43) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %102 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %103 = bitcast i8* %102 to %Qubit** - %qb__44 = load %Qubit*, %Qubit** %103, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 16, i64 1, %Array* %cc, %Qubit* %qb__44) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - %104 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %105 = bitcast i8* %104 to %Qubit** - %qb__46 = load %Qubit*, %Qubit** %105, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 1) - call void @__quantum__qis__single_qubit_op_ctl(i64 12, i64 1, %Array* %cc, %Qubit* %qb__46) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %cc, i32 -1) - call void @__quantum__rt__qubit_release_array(%Array* %cc) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) - call void @__quantum__rt__qubit_release_array(%Array* %qs) - ret void -} - -declare %Qubit* @__quantum__rt__qubit_allocate() - -declare %Array* @__quantum__rt__qubit_allocate_array(i64) - -declare void @__quantum__qis__inject_barrier(i64, i64) - -declare void @__quantum__rt__qubit_release(%Qubit*) - -declare void @__quantum__rt__qubit_release_array(%Array*) - -define void @Microsoft__Quantum__Testing__Tracer__TestMeasurements__body() { -entry: - %qs = call %Array* @__quantum__rt__qubit_allocate_array(i64 6) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 1) - %0 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %1 = bitcast i8* %0 to %Qubit** - %qb = load %Qubit*, %Qubit** %1, align 8 - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb) - %2 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 0) - %3 = bitcast i8* %2 to %Qubit** - %qb__2 = load %Qubit*, %Qubit** %3, align 8 - %r0 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__2) - %4 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %5 = bitcast i8* %4 to %Qubit** - %qb__4 = load %Qubit*, %Qubit** %5, align 8 - call void @__quantum__qis__single_qubit_op(i64 11, i64 1, %Qubit* %qb__4) - %6 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %7 = bitcast i8* %6 to %Qubit** - %8 = load %Qubit*, %Qubit** %7, align 8 - %9 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %10 = bitcast i8* %9 to %Qubit** - %11 = load %Qubit*, %Qubit** %10, align 8 - call void @Microsoft__Quantum__Intrinsic__CNOT__body(%Qubit* %8, %Qubit* %11) - %qs12 = call %Array* @__quantum__rt__array_create_1d(i32 8, i64 2) - %12 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) - %13 = bitcast i8* %12 to %Qubit** - %14 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 1) - %15 = bitcast i8* %14 to %Qubit** - %16 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 1) - %17 = bitcast i8* %16 to %Qubit** - %18 = load %Qubit*, %Qubit** %17, align 8 - %19 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 2) - %20 = bitcast i8* %19 to %Qubit** - %21 = load %Qubit*, %Qubit** %20, align 8 - store %Qubit* %18, %Qubit** %13, align 8 - store %Qubit* %21, %Qubit** %15, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %paulis = call %Array* @__quantum__rt__array_create_1d(i32 1, i64 2) - %22 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %23 = bitcast i8* %22 to i2* - %24 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %25 = bitcast i8* %24 to i2* - %26 = load i2, i2* @PauliY, align 1 - %27 = load i2, i2* @PauliX, align 1 - store i2 %26, i2* %23, align 1 - store i2 %27, i2* %25, align 1 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %28 = call %Result* @__quantum__rt__result_get_one() - %res = alloca %Result*, align 8 - store %Result* %28, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %28, i32 1) - %haveY = alloca i1, align 1 - store i1 false, i1* %haveY, align 1 - br label %header__1 - -header__1: ; preds = %exiting__1, %entry - %i = phi i64 [ 0, %entry ], [ %41, %exiting__1 ] - %29 = icmp sle i64 %i, 1 - br i1 %29, label %body__1, label %exit__1 - -body__1: ; preds = %header__1 - %30 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) - %31 = bitcast i8* %30 to i2* - %32 = load i2, i2* %31, align 1 - %33 = load i2, i2* @PauliY, align 1 - %34 = icmp eq i2 %32, %33 - br i1 %34, label %condContinue__1, label %condFalse__1 - -condFalse__1: ; preds = %body__1 - %35 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 %i) - %36 = bitcast i8* %35 to i2* - %37 = load i2, i2* %36, align 1 - %38 = load i2, i2* @PauliI, align 1 - %39 = icmp eq i2 %37, %38 - br label %condContinue__1 - -condContinue__1: ; preds = %condFalse__1, %body__1 - %40 = phi i1 [ %34, %body__1 ], [ %39, %condFalse__1 ] - br i1 %40, label %then0__1, label %continue__1 - -then0__1: ; preds = %condContinue__1 - store i1 true, i1* %haveY, align 1 - br label %continue__1 - -continue__1: ; preds = %then0__1, %condContinue__1 - br label %exiting__1 - -exiting__1: ; preds = %continue__1 - %41 = add i64 %i, 1 - br label %header__1 - -exit__1: ; preds = %header__1 - %42 = load i1, i1* %haveY, align 1 - br i1 %42, label %then0__2, label %test1__1 - -then0__2: ; preds = %exit__1 - %43 = call %Result* @__quantum__qis__joint_measure(i64 106, i64 1, %Array* %qs12) - call void @__quantum__rt__result_update_reference_count(%Result* %43, i32 1) - store %Result* %43, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %43, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %28, i32 -1) - br label %continue__2 - -test1__1: ; preds = %exit__1 - br i1 false, label %then1__1, label %test2__1 - -then1__1: ; preds = %test1__1 - %44 = call %Result* @__quantum__qis__joint_measure(i64 107, i64 1, %Array* %qs12) - call void @__quantum__rt__result_update_reference_count(%Result* %44, i32 1) - %45 = load %Result*, %Result** %res, align 8 - store %Result* %44, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %44, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %45, i32 -1) - br label %continue__2 - -test2__1: ; preds = %test1__1 - br i1 false, label %then2__1, label %test3__1 - -then2__1: ; preds = %test2__1 - %46 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %47 = bitcast i8* %46 to i2* - %48 = load i2, i2* %47, align 1 - %49 = load i2, i2* @PauliX, align 1 - %50 = icmp eq i2 %48, %49 - br i1 %50, label %then0__3, label %else__1 - -then0__3: ; preds = %then2__1 - %51 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) - %52 = bitcast i8* %51 to %Qubit** - %qb__6 = load %Qubit*, %Qubit** %52, align 8 - %53 = call %Result* @__quantum__qis__single_qubit_measure(i64 101, i64 1, %Qubit* %qb__6) - call void @__quantum__rt__result_update_reference_count(%Result* %53, i32 1) - %54 = load %Result*, %Result** %res, align 8 - store %Result* %53, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %53, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %54, i32 -1) - br label %continue__3 - -else__1: ; preds = %then2__1 - %55 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs12, i64 0) - %56 = bitcast i8* %55 to %Qubit** - %qb__7 = load %Qubit*, %Qubit** %56, align 8 - %57 = call %Result* @__quantum__qis__single_qubit_measure(i64 100, i64 1, %Qubit* %qb__7) - call void @__quantum__rt__result_update_reference_count(%Result* %57, i32 1) - %58 = load %Result*, %Result** %res, align 8 - store %Result* %57, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %57, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %58, i32 -1) - br label %continue__3 - -continue__3: ; preds = %else__1, %then0__3 - br label %continue__2 - -test3__1: ; preds = %test2__1 - %59 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %60 = bitcast i8* %59 to i2* - %61 = load i2, i2* %60, align 1 - %62 = load i2, i2* @PauliX, align 1 - %63 = icmp eq i2 %61, %62 - br i1 %63, label %condTrue__1, label %condContinue__2 - -condTrue__1: ; preds = %test3__1 - %64 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %65 = bitcast i8* %64 to i2* - %66 = load i2, i2* %65, align 1 - %67 = load i2, i2* @PauliX, align 1 - %68 = icmp eq i2 %66, %67 - br label %condContinue__2 - -condContinue__2: ; preds = %condTrue__1, %test3__1 - %69 = phi i1 [ %68, %condTrue__1 ], [ %63, %test3__1 ] - br i1 %69, label %then3__1, label %test4__1 - -then3__1: ; preds = %condContinue__2 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %70 = call %Result* @__quantum__qis__joint_measure(i64 105, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %70, i32 1) - %71 = load %Result*, %Result** %res, align 8 - store %Result* %70, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %70, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %71, i32 -1) - br label %continue__2 - -test4__1: ; preds = %condContinue__2 - %72 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %73 = bitcast i8* %72 to i2* - %74 = load i2, i2* %73, align 1 - %75 = load i2, i2* @PauliX, align 1 - %76 = icmp eq i2 %74, %75 - br i1 %76, label %condTrue__2, label %condContinue__3 - -condTrue__2: ; preds = %test4__1 - %77 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %78 = bitcast i8* %77 to i2* - %79 = load i2, i2* %78, align 1 - %80 = load i2, i2* @PauliZ, align 1 - %81 = icmp eq i2 %79, %80 - br label %condContinue__3 - -condContinue__3: ; preds = %condTrue__2, %test4__1 - %82 = phi i1 [ %81, %condTrue__2 ], [ %76, %test4__1 ] - br i1 %82, label %then4__1, label %test5__1 - -then4__1: ; preds = %condContinue__3 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %83 = call %Result* @__quantum__qis__joint_measure(i64 103, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %83, i32 1) - %84 = load %Result*, %Result** %res, align 8 - store %Result* %83, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %83, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %84, i32 -1) - br label %continue__2 - -test5__1: ; preds = %condContinue__3 - %85 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %86 = bitcast i8* %85 to i2* - %87 = load i2, i2* %86, align 1 - %88 = load i2, i2* @PauliZ, align 1 - %89 = icmp eq i2 %87, %88 - br i1 %89, label %condTrue__3, label %condContinue__4 - -condTrue__3: ; preds = %test5__1 - %90 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %91 = bitcast i8* %90 to i2* - %92 = load i2, i2* %91, align 1 - %93 = load i2, i2* @PauliX, align 1 - %94 = icmp eq i2 %92, %93 - br label %condContinue__4 - -condContinue__4: ; preds = %condTrue__3, %test5__1 - %95 = phi i1 [ %94, %condTrue__3 ], [ %89, %test5__1 ] - br i1 %95, label %then5__1, label %test6__1 - -then5__1: ; preds = %condContinue__4 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %96 = call %Result* @__quantum__qis__joint_measure(i64 104, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %96, i32 1) - %97 = load %Result*, %Result** %res, align 8 - store %Result* %96, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %96, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %97, i32 -1) - br label %continue__2 - -test6__1: ; preds = %condContinue__4 - %98 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 0) - %99 = bitcast i8* %98 to i2* - %100 = load i2, i2* %99, align 1 - %101 = load i2, i2* @PauliZ, align 1 - %102 = icmp eq i2 %100, %101 - br i1 %102, label %condTrue__4, label %condContinue__5 - -condTrue__4: ; preds = %test6__1 - %103 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %paulis, i64 1) - %104 = bitcast i8* %103 to i2* - %105 = load i2, i2* %104, align 1 - %106 = load i2, i2* @PauliZ, align 1 - %107 = icmp eq i2 %105, %106 - br label %condContinue__5 - -condContinue__5: ; preds = %condTrue__4, %test6__1 - %108 = phi i1 [ %107, %condTrue__4 ], [ %102, %test6__1 ] - br i1 %108, label %then6__1, label %continue__2 - -then6__1: ; preds = %condContinue__5 - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 1) - %109 = call %Result* @__quantum__qis__joint_measure(i64 102, i64 1, %Array* %qs12) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %109, i32 1) - %110 = load %Result*, %Result** %res, align 8 - store %Result* %109, %Result** %res, align 8 - call void @__quantum__rt__result_update_reference_count(%Result* %109, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %110, i32 -1) - br label %continue__2 - -continue__2: ; preds = %then6__1, %condContinue__5, %then5__1, %then4__1, %then3__1, %continue__3, %then1__1, %then0__2 - %r12 = load %Result*, %Result** %res, align 8 - call void @__quantum__rt__array_update_alias_count(%Array* %paulis, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %paulis, i32 -1) - %111 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %112 = bitcast %Tuple* %111 to { %Callable*, %Callable*, %Qubit* }* - %113 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 0 - %114 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 1 - %115 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %112, i32 0, i32 2 - %116 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %117 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__X, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %118 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 3) - %119 = bitcast i8* %118 to %Qubit** - %120 = load %Qubit*, %Qubit** %119, align 8 - store %Callable* %116, %Callable** %113, align 8 - store %Callable* %117, %Callable** %114, align 8 - store %Qubit* %120, %Qubit** %115, align 8 - %121 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__1, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %111) - %122 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %123 = bitcast %Tuple* %122 to { %Callable*, %Callable*, %Qubit* }* - %124 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 0 - %125 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 1 - %126 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %123, i32 0, i32 2 - %127 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %128 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Y, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %129 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 3) - %130 = bitcast i8* %129 to %Qubit** - %131 = load %Qubit*, %Qubit** %130, align 8 - store %Callable* %127, %Callable** %124, align 8 - store %Callable* %128, %Callable** %125, align 8 - store %Qubit* %131, %Qubit** %126, align 8 - %132 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__2, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %122) - call void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %r0, %Callable* %121, %Callable* %132) - %133 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %134 = bitcast %Tuple* %133 to { %Callable*, %Callable*, %Qubit* }* - %135 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 0 - %136 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 1 - %137 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %134, i32 0, i32 2 - %138 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %139 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__Z, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %140 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 4) - %141 = bitcast i8* %140 to %Qubit** - %142 = load %Qubit*, %Qubit** %141, align 8 - store %Callable* %138, %Callable** %135, align 8 - store %Callable* %139, %Callable** %136, align 8 - store %Qubit* %142, %Qubit** %137, align 8 - %143 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__3, [2 x void (%Tuple*, i32)*]* @MemoryManagement__1, %Tuple* %133) - %144 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %145 = bitcast %Tuple* %144 to { %Callable*, %Callable*, %Qubit* }* - %146 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 0 - %147 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 1 - %148 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %145, i32 0, i32 2 - %149 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Testing__Tracer__Delay, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %150 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @Microsoft__Quantum__Intrinsic__S, [2 x void (%Tuple*, i32)*]* null, %Tuple* null) - %151 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 4) - %152 = bitcast i8* %151 to %Qubit** - %153 = load %Qubit*, %Qubit** %152, align 8 - store %Callable* %149, %Callable** %146, align 8 - store %Callable* %150, %Callable** %147, align 8 - store %Qubit* %153, %Qubit** %148, align 8 - %154 = call %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]* @PartialApplication__4, [2 x void (%Tuple*, i32)*]* @MemoryManagement__2, %Tuple* %144) - call void @Microsoft__Quantum__Intrinsic__ApplyIfElseIntrinsic__body(%Result* %r12, %Callable* %143, %Callable* %154) - %155 = call i8* @__quantum__rt__array_get_element_ptr_1d(%Array* %qs, i64 5) - %156 = bitcast i8* %155 to %Qubit** - %qb__8 = load %Qubit*, %Qubit** %156, align 8 - call void @__quantum__qis__single_qubit_op(i64 19, i64 1, %Qubit* %qb__8) - call void @__quantum__rt__array_update_alias_count(%Array* %qs, i32 -1) - call void @__quantum__rt__array_update_alias_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %r0, i32 -1) - call void @__quantum__rt__array_update_reference_count(%Array* %qs12, i32 -1) - call void @__quantum__rt__result_update_reference_count(%Result* %r12, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %121, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %121, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %132, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %132, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %143, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %143, i32 -1) - call void @__quantum__rt__capture_update_reference_count(%Callable* %154, i32 -1) - call void @__quantum__rt__callable_update_reference_count(%Callable* %154, i32 -1) - call void @__quantum__rt__qubit_release_array(%Array* %qs) - ret void -} - -define void @Microsoft__Quantum__Testing__Tracer__Delay__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Callable*, %Qubit*, %Tuple* }* - %1 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 1 - %3 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %0, i32 0, i32 2 - %4 = load %Callable*, %Callable** %1, align 8 - %5 = load %Qubit*, %Qubit** %2, align 8 - %6 = load %Tuple*, %Tuple** %3, align 8 - call void @Microsoft__Quantum__Testing__Tracer__Delay__body(%Callable* %4, %Qubit* %5, %Tuple* %6) - ret void -} - -declare %Callable* @__quantum__rt__callable_create([4 x void (%Tuple*, %Tuple*, %Tuple*)*]*, [2 x void (%Tuple*, i32)*]*, %Tuple*) - -define void @Microsoft__Quantum__Intrinsic__X__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__X__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__X__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__X__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__X__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__X__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Lifted__PartialApplication__1__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1, align 8 - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* - %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* - %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10, align 8 - store %Qubit* %4, %Qubit** %11, align 8 - store %Tuple* %7, %Tuple** %12, align 8 - %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - ret void -} - -define void @MemoryManagement__1__RefCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3, align 8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -define void @MemoryManagement__1__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3, align 8 - call void @__quantum__rt__capture_update_alias_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Y__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Y__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Lifted__PartialApplication__2__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1, align 8 - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* - %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* - %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10, align 8 - store %Qubit* %4, %Qubit** %11, align 8 - store %Tuple* %7, %Tuple** %12, align 8 - %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__Z__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__Z__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Lifted__PartialApplication__3__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1, align 8 - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* - %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* - %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10, align 8 - store %Qubit* %4, %Qubit** %11, align 8 - store %Tuple* %7, %Tuple** %12, align 8 - %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__S__body(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__adj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Qubit* }* - %1 = getelementptr inbounds { %Qubit* }, { %Qubit* }* %0, i32 0, i32 0 - %2 = load %Qubit*, %Qubit** %1, align 8 - call void @Microsoft__Quantum__Intrinsic__S__adj(%Qubit* %2) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctl__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__S__ctl(%Array* %3, %Qubit* %4) - ret void -} - -define void @Microsoft__Quantum__Intrinsic__S__ctladj__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %arg-tuple to { %Array*, %Qubit* }* - %1 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 0 - %2 = getelementptr inbounds { %Array*, %Qubit* }, { %Array*, %Qubit* }* %0, i32 0, i32 1 - %3 = load %Array*, %Array** %1, align 8 - %4 = load %Qubit*, %Qubit** %2, align 8 - call void @Microsoft__Quantum__Intrinsic__S__ctladj(%Array* %3, %Qubit* %4) - ret void -} - -define void @Lifted__PartialApplication__4__body__wrapper(%Tuple* %capture-tuple, %Tuple* %arg-tuple, %Tuple* %result-tuple) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %2 = load %Callable*, %Callable** %1, align 8 - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 2 - %4 = load %Qubit*, %Qubit** %3, align 8 - %5 = bitcast %Tuple* %arg-tuple to { %Tuple* }* - %6 = getelementptr inbounds { %Tuple* }, { %Tuple* }* %5, i32 0, i32 0 - %7 = load %Tuple*, %Tuple** %6, align 8 - %8 = call %Tuple* @__quantum__rt__tuple_create(i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 3)) - %9 = bitcast %Tuple* %8 to { %Callable*, %Qubit*, %Tuple* }* - %10 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 0 - %11 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 1 - %12 = getelementptr inbounds { %Callable*, %Qubit*, %Tuple* }, { %Callable*, %Qubit*, %Tuple* }* %9, i32 0, i32 2 - store %Callable* %2, %Callable** %10, align 8 - store %Qubit* %4, %Qubit** %11, align 8 - store %Tuple* %7, %Tuple** %12, align 8 - %13 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %14 = load %Callable*, %Callable** %13, align 8 - call void @__quantum__rt__callable_invoke(%Callable* %14, %Tuple* %8, %Tuple* %result-tuple) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %8, i32 -1) - ret void -} - -define void @MemoryManagement__2__RefCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %2, i32 %count-change) - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3, align 8 - call void @__quantum__rt__capture_update_reference_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__callable_update_reference_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__tuple_update_reference_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -define void @MemoryManagement__2__AliasCount(%Tuple* %capture-tuple, i32 %count-change) { -entry: - %0 = bitcast %Tuple* %capture-tuple to { %Callable*, %Callable*, %Qubit* }* - %1 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 0 - %2 = load %Callable*, %Callable** %1, align 8 - call void @__quantum__rt__capture_update_alias_count(%Callable* %2, i32 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %2, i32 %count-change) - %3 = getelementptr inbounds { %Callable*, %Callable*, %Qubit* }, { %Callable*, %Callable*, %Qubit* }* %0, i32 0, i32 1 - %4 = load %Callable*, %Callable** %3, align 8 - call void @__quantum__rt__capture_update_alias_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__callable_update_alias_count(%Callable* %4, i32 %count-change) - call void @__quantum__rt__tuple_update_alias_count(%Tuple* %capture-tuple, i32 %count-change) - ret void -} - -declare void @__quantum__rt__capture_update_reference_count(%Callable*, i32) - -declare void @__quantum__rt__callable_update_reference_count(%Callable*, i32) - -define %Tuple* @Microsoft__Quantum__Core__Attribute__body() { -entry: - ret %Tuple* null -} - -define %Tuple* @Microsoft__Quantum__Core__EntryPoint__body() { -entry: - ret %Tuple* null -} - -define %Tuple* @Microsoft__Quantum__Core__Inline__body() { -entry: - ret %Tuple* null -} - -define { %String* }* @Microsoft__Quantum__Targeting__TargetInstruction__body(%String* %__Item1__) { -entry: - %0 = call %Tuple* @__quantum__rt__tuple_create(i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64)) - %1 = bitcast %Tuple* %0 to { %String* }* - %2 = getelementptr inbounds { %String* }, { %String* }* %1, i32 0, i32 0 - store %String* %__Item1__, %String** %2, align 8 - call void @__quantum__rt__string_update_reference_count(%String* %__Item1__, i32 1) - ret { %String* }* %1 -} - -declare void @__quantum__rt__string_update_reference_count(%String*, i32) - -declare void @__quantum__rt__tuple_update_alias_count(%Tuple*, i32) From 2192093d1fe5de82387d82b672765ea86920b7d4 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Thu, 18 Mar 2021 14:52:27 -0700 Subject: [PATCH 14/14] CR change --- .../test/FullstateSimulator/qsharp/qir-test-simulator.qs | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/QirRuntime/test/FullstateSimulator/qsharp/qir-test-simulator.qs b/src/QirRuntime/test/FullstateSimulator/qsharp/qir-test-simulator.qs index 3b6d3eee483..bb97857e50c 100644 --- a/src/QirRuntime/test/FullstateSimulator/qsharp/qir-test-simulator.qs +++ b/src/QirRuntime/test/FullstateSimulator/qsharp/qir-test-simulator.qs @@ -22,8 +22,11 @@ namespace Microsoft.Quantum.Testing.QIR Controlled op(ctls, target); Adjoint Controlled op(ctls, target); if (M(target) != Zero) { set res = 2; } - H(ctls[0]); - H(ctls[1]); + else + { + H(ctls[0]); + H(ctls[1]); + } } } return res;