This is an archive of the discontinued LLVM Phabricator instance.

Differential D119926

[Clang][AArch64] Enable _Float16 _Complex type
AbandonedPublic

Authored by MattDevereau on Feb 16 2022, 2:45 AM.

Details

Reviewers
georges
peterwaller-arm
paulwalker-arm
DavidTruby
bsmith
teemperor
rjmccall
qiucf
aaron.ballman

Diff Detail

Event Timeline

MattDevereau created this revision.Feb 16 2022, 2:45 AM
Herald added a subscriber: kristof.beyls. · View Herald TranscriptFeb 16 2022, 2:45 AM
MattDevereau requested review of this revision.Feb 16 2022, 2:45 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 16 2022, 2:45 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
paulwalker-arm added inline comments.Feb 16 2022, 2:53 AM
clang/include/clang/AST/ASTContext.h
1117 ↗(On Diff #409186)

Is this necessary? I don't see any other *ComplexTy types in this file (i.e. there is no DoubleComplexTy).

clang/lib/AST/ASTContext.cpp
1330

As above.

peterwaller-arm added a comment.Feb 16 2022, 2:57 AM

Some comments.

clang/include/clang/AST/ASTContext.h
1117 ↗(On Diff #409186)

Is this necessary?

clang/lib/AST/ASTContext.cpp
1330

Is this necessary?

6810–6812

This can be left unmodified.

clang/test/CodeGen/aarch64-complex-half-math.c
2

Can these test outputs be autogenerated with update_cc_test_checks.py?

3

I think this test needs a // REQUIRES: aarch64-registered-target to protect builds which don't have a LLVM_TARGETS_TO_BUILD which implies AArch64 is available.

6

My read is that this appears to be testing both -ffast-math and _Float16. Do we want to be testing both these things at once like this, can anyone comment?

My preference would be to have these test only the operators, and not the flags, and then maybe have a single test which does
https://clang.llvm.org/docs/LanguageExtensions.html#extensions-to-specify-floating-point-flags

#pragma clang fp contract(fast)

and verifies that the flags are present.

fhahn added a reviewer: aaron.ballman.Feb 16 2022, 3:03 AM
fhahn added a subscriber: fhahn.
fhahn added inline comments.
clang/test/CodeGen/aarch64-complex-half-math.c
2

Do the tests need to depend on LLVM optimizations? In general this is undesirable as it makes them more fragile if things change on the LLVM side.

Harbormaster completed remote builds in B149916: Diff 409186.Feb 16 2022, 3:37 AM
aaron.ballman added inline comments.Feb 16 2022, 5:33 AM
clang/include/clang/AST/ASTContext.h
1117 ↗(On Diff #409186)

This is the wrong way to handle this -- complex types are stored in the ComplexTypes folding set and are created through ASTContext::getComplexType(). So I don't think this change is necessary.

clang/lib/AST/ASTContext.cpp
1330

Same here.

MattDevereau updated this revision to Diff 409236.Feb 16 2022, 6:52 AM

Removed -O1 and -ffast-math flags

Harbormaster completed remote builds in B149953: Diff 409236.Feb 16 2022, 7:28 AM
peterwaller-arm accepted this revision.Feb 16 2022, 7:48 AM

LGTM.

clang/test/CodeGen/aarch64-complex-half-math.c
6

Discussed off-review: concluded for now that a no-optimizations test with no fast math flags seems reasonable, to address @fhahn's comment.

This revision is now accepted and ready to land.Feb 16 2022, 7:48 AM
aaron.ballman added inline comments.Feb 17 2022, 5:22 AM
clang/test/CodeGen/aarch64-complex-half-math.c
3

There's nothing AArch64-specific about the change, so I'd expect some more general codegen tests.

Actually, I took a look to see what calls getFloatingTypeOfSizeWithinDomain() and I can't find any callers of that. Do you have a test case where you were hitting that particular unreachable?

peterwaller-arm added inline comments.Feb 23 2022, 5:43 AM
clang/test/CodeGen/aarch64-complex-half-math.c
3

Thanks for your observation @aaron.ballman.

It appears this has been working since D105331, which enabled it for X86.

Unless I'm missing something, the function in question appears to have been unused since 2010 (the last use was removed in d005ac937e4c08e0c607ddc42708f8bf2064c243 by @rjmccall), I presume getFloatingTypeOfSizeWithinDomain should be removed then.

aaron.ballman added inline comments.Feb 23 2022, 6:10 AM
clang/test/CodeGen/aarch64-complex-half-math.c
3

I presume getFloatingTypeOfSizeWithinDomain should be removed then.

Agreed; I've gone ahead and removed it in 841355c1e4e35fc02b5b171419979f5f9af0ebc8.

I think this patch can be abandoned, unless you think the extra test coverage is worth adding as an NFC commit?

MattDevereau abandoned this revision.EditedFeb 28 2022, 5:34 AM

Abandoning this patch as it is redundant due to changes in D105331. This patch also drew attention to unused code that has since been removed in 841355c1e4e35fc02b5b171419979f5f9af0ebc8. Many thanks to @aaron.ballman

Revision Contents

PathSize
clang/
lib/
AST/
2 lines
test/
CodeGen/
419 lines

Diff 409236

clang/lib/AST/ASTContext.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,321 Lines • ▼ Show 20 Linesvoid ASTContext::InitBuiltinTypes(const TargetInfo &Target,
// GNU extension, __float128 for IEEE quadruple precision // GNU extension, __float128 for IEEE quadruple precision
InitBuiltinType(Float128Ty, BuiltinType::Float128); InitBuiltinType(Float128Ty, BuiltinType::Float128);
// __ibm128 for IBM extended precision // __ibm128 for IBM extended precision
InitBuiltinType(Ibm128Ty, BuiltinType::Ibm128); InitBuiltinType(Ibm128Ty, BuiltinType::Ibm128);
// C11 extension ISO/IEC TS 18661-3 // C11 extension ISO/IEC TS 18661-3
InitBuiltinType(Float16Ty, BuiltinType::Float16); InitBuiltinType(Float16Ty, BuiltinType::Float16);
peterwaller-armUnsubmitted
Not Done
ReplyInline Actions

Is this necessary?

peterwaller-arm: Is this necessary?
paulwalker-armUnsubmitted
Not Done
ReplyInline Actions

As above.

paulwalker-arm: As above.
aaron.ballmanUnsubmitted
Not Done
ReplyInline Actions

Same here.

aaron.ballman: Same here.
// ISO/IEC JTC1 SC22 WG14 N1169 Extension // ISO/IEC JTC1 SC22 WG14 N1169 Extension
InitBuiltinType(ShortAccumTy, BuiltinType::ShortAccum); InitBuiltinType(ShortAccumTy, BuiltinType::ShortAccum);
InitBuiltinType(AccumTy, BuiltinType::Accum); InitBuiltinType(AccumTy, BuiltinType::Accum);
InitBuiltinType(LongAccumTy, BuiltinType::LongAccum); InitBuiltinType(LongAccumTy, BuiltinType::LongAccum);
InitBuiltinType(UnsignedShortAccumTy, BuiltinType::UShortAccum); InitBuiltinType(UnsignedShortAccumTy, BuiltinType::UShortAccum);
InitBuiltinType(UnsignedAccumTy, BuiltinType::UAccum); InitBuiltinType(UnsignedAccumTy, BuiltinType::UAccum);
InitBuiltinType(UnsignedLongAccumTy, BuiltinType::ULongAccum); InitBuiltinType(UnsignedLongAccumTy, BuiltinType::ULongAccum);
InitBuiltinType(ShortFractTy, BuiltinType::ShortFract); InitBuiltinType(ShortFractTy, BuiltinType::ShortFract);
▲ Show 20 Lines • Show All 5,463 Lines • ▼ Show 20 Lines
/// point or a complex type (based on typeDomain/typeSize). /// point or a complex type (based on typeDomain/typeSize).
/// 'typeDomain' is a real floating point or complex type. /// 'typeDomain' is a real floating point or complex type.
/// 'typeSize' is a real floating point or complex type. /// 'typeSize' is a real floating point or complex type.
QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size, QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
QualType Domain) const { QualType Domain) const {
FloatingRank EltRank = getFloatingRank(Size); FloatingRank EltRank = getFloatingRank(Size);
if (Domain->isComplexType()) { if (Domain->isComplexType()) {
switch (EltRank) { switch (EltRank) {
case BFloat16Rank: llvm_unreachable("Complex bfloat16 is not supported"); case BFloat16Rank: llvm_unreachable("Complex bfloat16 is not supported");
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-    case BFloat16Rank: llvm_unreachable("Complex bfloat16 is not supported");
+    case BFloat16Rank:
+      llvm_unreachable("Complex bfloat16 is not supported");
Lint: Pre-merge checks: clang-format: please reformat the code ``` - case BFloat16Rank: llvm_unreachable("Complex…
case Float16Rank:
case HalfRank: llvm_unreachable("Complex half is not supported"); case HalfRank: llvm_unreachable("Complex half is not supported");
case Float16Rank: return getComplexType(Float16Ty);
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-    case Float16Rank:    return getComplexType(Float16Ty);
+    case Float16Rank:
+      return getComplexType(Float16Ty);
Lint: Pre-merge checks: clang-format: please reformat the code ``` - case Float16Rank: return getComplexType…
peterwaller-armUnsubmitted
Not Done
ReplyInline Actions

This can be left unmodified.

peterwaller-arm: This can be left unmodified.
case Ibm128Rank: return getComplexType(Ibm128Ty); case Ibm128Rank: return getComplexType(Ibm128Ty);
case FloatRank: return getComplexType(FloatTy); case FloatRank: return getComplexType(FloatTy);
case DoubleRank: return getComplexType(DoubleTy); case DoubleRank: return getComplexType(DoubleTy);
case LongDoubleRank: return getComplexType(LongDoubleTy); case LongDoubleRank: return getComplexType(LongDoubleTy);
case Float128Rank: return getComplexType(Float128Ty); case Float128Rank: return getComplexType(Float128Ty);
} }
} }
▲ Show 20 Lines • Show All 5,473 Lines • Show Last 20 Lines

clang/test/CodeGen/aarch64-complex-half-math.c

  • This file was added.
// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
// RUN: %clang_cc1 %s -emit-llvm -triple aarch64-unknown-unknown -o - | FileCheck %s --check-prefix=AARCH64
peterwaller-armUnsubmitted
Not Done
ReplyInline Actions

Can these test outputs be autogenerated with update_cc_test_checks.py?

peterwaller-arm: Can these test outputs be autogenerated with update_cc_test_checks.py?
fhahnUnsubmitted
Not Done
ReplyInline Actions

Do the tests need to depend on LLVM optimizations? In general this is undesirable as it makes them more fragile if things change on the LLVM side.

fhahn: Do the tests need to depend on LLVM optimizations? In general this is undesirable as it makes…
// REQUIRES: aarch64-registered-target
peterwaller-armUnsubmitted
Not Done
ReplyInline Actions

I think this test needs a // REQUIRES: aarch64-registered-target to protect builds which don't have a LLVM_TARGETS_TO_BUILD which implies AArch64 is available.

peterwaller-arm: I think this test needs a `// REQUIRES: aarch64-registered-target` to protect builds which…
aaron.ballmanUnsubmitted
Not Done
ReplyInline Actions

There's nothing AArch64-specific about the change, so I'd expect some more general codegen tests.

Actually, I took a look to see what calls getFloatingTypeOfSizeWithinDomain() and I can't find any callers of that. Do you have a test case where you were hitting that particular unreachable?

aaron.ballman: There's nothing AArch64-specific about the change, so I'd expect some more general codegen…
peterwaller-armUnsubmitted
Not Done
ReplyInline Actions

Thanks for your observation @aaron.ballman.

It appears this has been working since D105331, which enabled it for X86.

Unless I'm missing something, the function in question appears to have been unused since 2010 (the last use was removed in d005ac937e4c08e0c607ddc42708f8bf2064c243 by @rjmccall), I presume getFloatingTypeOfSizeWithinDomain should be removed then.

peterwaller-arm: Thanks for your observation @aaron.ballman. It appears this has been working since D105331…
aaron.ballmanUnsubmitted
Not Done
ReplyInline Actions

I presume getFloatingTypeOfSizeWithinDomain should be removed then.

Agreed; I've gone ahead and removed it in 841355c1e4e35fc02b5b171419979f5f9af0ebc8.

I think this patch can be abandoned, unless you think the extra test coverage is worth adding as an NFC commit?

aaron.ballman: > I presume getFloatingTypeOfSizeWithinDomain should be removed then. Agreed; I've gone ahead…
// AARCH64-LABEL: @add_float_rr(
// AARCH64-NEXT: entry:
peterwaller-armUnsubmitted
Not Done
ReplyInline Actions

My read is that this appears to be testing both -ffast-math and _Float16. Do we want to be testing both these things at once like this, can anyone comment?

My preference would be to have these test only the operators, and not the flags, and then maybe have a single test which does
https://clang.llvm.org/docs/LanguageExtensions.html#extensions-to-specify-floating-point-flags

#pragma clang fp contract(fast)

and verifies that the flags are present.

peterwaller-arm: My read is that this appears to be testing both -ffast-math and _Float16. Do we want to be…
peterwaller-armUnsubmitted
Not Done
ReplyInline Actions

Discussed off-review: concluded for now that a no-optimizations test with no fast math flags seems reasonable, to address @fhahn's comment.

peterwaller-arm: Discussed off-review: concluded for now that a no-optimizations test with no fast math flags…
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[B_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: store half [[A:%.*]], half* [[A_ADDR]], align 2
// AARCH64-NEXT: store half [[B:%.*]], half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[TMP0:%.*]] = load half, half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[ADD:%.*]] = fadd half [[TMP0]], [[TMP1]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[ADD]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half 0xH0000, half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex add_float_rr(_Float16 a, _Float16 b) {
return a + b;
}
// AARCH64-LABEL: @add_float_cr(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[A]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[A_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: store half [[B:%.*]], half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[A_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 0
// AARCH64-NEXT: [[A_REAL:%.*]] = load half, half* [[A_REALP]], align 2
// AARCH64-NEXT: [[A_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 1
// AARCH64-NEXT: [[A_IMAG:%.*]] = load half, half* [[A_IMAGP]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[ADD_R:%.*]] = fadd half [[A_REAL]], [[TMP1]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[ADD_R]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[A_IMAG]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex add_float_cr(_Float16 _Complex a, _Float16 b) {
return a + b;
}
// AARCH64-LABEL: @add_float_rc(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[B]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[B_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: store half [[A:%.*]], half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[B_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 0
// AARCH64-NEXT: [[B_REAL:%.*]] = load half, half* [[B_REALP]], align 2
// AARCH64-NEXT: [[B_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 1
// AARCH64-NEXT: [[B_IMAG:%.*]] = load half, half* [[B_IMAGP]], align 2
// AARCH64-NEXT: [[ADD_R:%.*]] = fadd half [[TMP1]], [[B_REAL]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[ADD_R]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[B_IMAG]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex add_float_rc(_Float16 a, _Float16 _Complex b) {
return a + b;
}
// AARCH64-LABEL: @add_float_cc(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[A]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[A_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = bitcast { half, half }* [[B]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[B_COERCE:%.*]], [2 x half]* [[TMP1]], align 2
// AARCH64-NEXT: [[A_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 0
// AARCH64-NEXT: [[A_REAL:%.*]] = load half, half* [[A_REALP]], align 2
// AARCH64-NEXT: [[A_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 1
// AARCH64-NEXT: [[A_IMAG:%.*]] = load half, half* [[A_IMAGP]], align 2
// AARCH64-NEXT: [[B_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 0
// AARCH64-NEXT: [[B_REAL:%.*]] = load half, half* [[B_REALP]], align 2
// AARCH64-NEXT: [[B_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 1
// AARCH64-NEXT: [[B_IMAG:%.*]] = load half, half* [[B_IMAGP]], align 2
// AARCH64-NEXT: [[ADD_R:%.*]] = fadd half [[A_REAL]], [[B_REAL]]
// AARCH64-NEXT: [[ADD_I:%.*]] = fadd half [[A_IMAG]], [[B_IMAG]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[ADD_R]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[ADD_I]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex add_float_cc(_Float16 _Complex a, _Float16 _Complex b) {
return a + b;
}
// AARCH64-LABEL: @sub_float_rr(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[B_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: store half [[A:%.*]], half* [[A_ADDR]], align 2
// AARCH64-NEXT: store half [[B:%.*]], half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[TMP0:%.*]] = load half, half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[SUB:%.*]] = fsub half [[TMP0]], [[TMP1]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[SUB]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half 0xH0000, half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex sub_float_rr(_Float16 a, _Float16 b) {
return a - b;
}
// AARCH64-LABEL: @sub_float_cr(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[A]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[A_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: store half [[B:%.*]], half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[A_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 0
// AARCH64-NEXT: [[A_REAL:%.*]] = load half, half* [[A_REALP]], align 2
// AARCH64-NEXT: [[A_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 1
// AARCH64-NEXT: [[A_IMAG:%.*]] = load half, half* [[A_IMAGP]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[SUB_R:%.*]] = fsub half [[A_REAL]], [[TMP1]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[SUB_R]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[A_IMAG]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex sub_float_cr(_Float16 _Complex a, _Float16 b) {
return a - b;
}
// AARCH64-LABEL: @sub_float_rc(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[B]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[B_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: store half [[A:%.*]], half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[B_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 0
// AARCH64-NEXT: [[B_REAL:%.*]] = load half, half* [[B_REALP]], align 2
// AARCH64-NEXT: [[B_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 1
// AARCH64-NEXT: [[B_IMAG:%.*]] = load half, half* [[B_IMAGP]], align 2
// AARCH64-NEXT: [[SUB_R:%.*]] = fsub half [[TMP1]], [[B_REAL]]
// AARCH64-NEXT: [[SUB_I:%.*]] = fneg half [[B_IMAG]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[SUB_R]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[SUB_I]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex sub_float_rc(_Float16 a, _Float16 _Complex b) {
return a - b;
}
// AARCH64-LABEL: @sub_float_cc(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[A]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[A_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = bitcast { half, half }* [[B]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[B_COERCE:%.*]], [2 x half]* [[TMP1]], align 2
// AARCH64-NEXT: [[A_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 0
// AARCH64-NEXT: [[A_REAL:%.*]] = load half, half* [[A_REALP]], align 2
// AARCH64-NEXT: [[A_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 1
// AARCH64-NEXT: [[A_IMAG:%.*]] = load half, half* [[A_IMAGP]], align 2
// AARCH64-NEXT: [[B_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 0
// AARCH64-NEXT: [[B_REAL:%.*]] = load half, half* [[B_REALP]], align 2
// AARCH64-NEXT: [[B_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 1
// AARCH64-NEXT: [[B_IMAG:%.*]] = load half, half* [[B_IMAGP]], align 2
// AARCH64-NEXT: [[SUB_R:%.*]] = fsub half [[A_REAL]], [[B_REAL]]
// AARCH64-NEXT: [[SUB_I:%.*]] = fsub half [[A_IMAG]], [[B_IMAG]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[SUB_R]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[SUB_I]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex sub_float_cc(_Float16 _Complex a, _Float16 _Complex b) {
return a - b;
}
// AARCH64-LABEL: @mul_float_rr(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[B_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: store half [[A:%.*]], half* [[A_ADDR]], align 2
// AARCH64-NEXT: store half [[B:%.*]], half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[TMP0:%.*]] = load half, half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[MUL:%.*]] = fmul half [[TMP0]], [[TMP1]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[MUL]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half 0xH0000, half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex mul_float_rr(_Float16 a, _Float16 b) {
return a * b;
}
// AARCH64-LABEL: @mul_float_cr(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[A]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[A_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: store half [[B:%.*]], half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[A_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 0
// AARCH64-NEXT: [[A_REAL:%.*]] = load half, half* [[A_REALP]], align 2
// AARCH64-NEXT: [[A_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 1
// AARCH64-NEXT: [[A_IMAG:%.*]] = load half, half* [[A_IMAGP]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[MUL_RL:%.*]] = fmul half [[A_REAL]], [[TMP1]]
// AARCH64-NEXT: [[MUL_IL:%.*]] = fmul half [[A_IMAG]], [[TMP1]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[MUL_RL]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[MUL_IL]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex mul_float_cr(_Float16 _Complex a, _Float16 b) {
return a * b;
}
// AARCH64-LABEL: @mul_float_rc(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[B]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[B_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: store half [[A:%.*]], half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[B_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 0
// AARCH64-NEXT: [[B_REAL:%.*]] = load half, half* [[B_REALP]], align 2
// AARCH64-NEXT: [[B_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 1
// AARCH64-NEXT: [[B_IMAG:%.*]] = load half, half* [[B_IMAGP]], align 2
// AARCH64-NEXT: [[MUL_RL:%.*]] = fmul half [[TMP1]], [[B_REAL]]
// AARCH64-NEXT: [[MUL_IR:%.*]] = fmul half [[TMP1]], [[B_IMAG]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[MUL_RL]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[MUL_IR]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex mul_float_rc(_Float16 a, _Float16 _Complex b) {
return a * b;
}
// AARCH64-LABEL: @mul_float_cc(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[A]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[A_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = bitcast { half, half }* [[B]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[B_COERCE:%.*]], [2 x half]* [[TMP1]], align 2
// AARCH64-NEXT: [[A_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 0
// AARCH64-NEXT: [[A_REAL:%.*]] = load half, half* [[A_REALP]], align 2
// AARCH64-NEXT: [[A_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 1
// AARCH64-NEXT: [[A_IMAG:%.*]] = load half, half* [[A_IMAGP]], align 2
// AARCH64-NEXT: [[B_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 0
// AARCH64-NEXT: [[B_REAL:%.*]] = load half, half* [[B_REALP]], align 2
// AARCH64-NEXT: [[B_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 1
// AARCH64-NEXT: [[B_IMAG:%.*]] = load half, half* [[B_IMAGP]], align 2
// AARCH64-NEXT: [[MUL_AC:%.*]] = fmul half [[A_REAL]], [[B_REAL]]
// AARCH64-NEXT: [[MUL_BD:%.*]] = fmul half [[A_IMAG]], [[B_IMAG]]
// AARCH64-NEXT: [[MUL_AD:%.*]] = fmul half [[A_REAL]], [[B_IMAG]]
// AARCH64-NEXT: [[MUL_BC:%.*]] = fmul half [[A_IMAG]], [[B_REAL]]
// AARCH64-NEXT: [[MUL_R:%.*]] = fsub half [[MUL_AC]], [[MUL_BD]]
// AARCH64-NEXT: [[MUL_I:%.*]] = fadd half [[MUL_AD]], [[MUL_BC]]
// AARCH64-NEXT: [[ISNAN_CMP:%.*]] = fcmp uno half [[MUL_R]], [[MUL_R]]
// AARCH64-NEXT: br i1 [[ISNAN_CMP]], label [[COMPLEX_MUL_IMAG_NAN:%.*]], label [[COMPLEX_MUL_CONT:%.*]], !prof [[PROF6:![0-9]+]]
// AARCH64: complex_mul_imag_nan:
// AARCH64-NEXT: [[ISNAN_CMP1:%.*]] = fcmp uno half [[MUL_I]], [[MUL_I]]
// AARCH64-NEXT: br i1 [[ISNAN_CMP1]], label [[COMPLEX_MUL_LIBCALL:%.*]], label [[COMPLEX_MUL_CONT]], !prof [[PROF6]]
// AARCH64: complex_mul_libcall:
// AARCH64-NEXT: [[CALL:%.*]] = call { half, half } @__mulhc3(half noundef [[A_REAL]], half noundef [[A_IMAG]], half noundef [[B_REAL]], half noundef [[B_IMAG]]) #[[ATTR1:[0-9]+]]
// AARCH64-NEXT: [[TMP2:%.*]] = extractvalue { half, half } [[CALL]], 0
// AARCH64-NEXT: [[TMP3:%.*]] = extractvalue { half, half } [[CALL]], 1
// AARCH64-NEXT: br label [[COMPLEX_MUL_CONT]]
// AARCH64: complex_mul_cont:
// AARCH64-NEXT: [[REAL_MUL_PHI:%.*]] = phi half [ [[MUL_R]], [[ENTRY:%.*]] ], [ [[MUL_R]], [[COMPLEX_MUL_IMAG_NAN]] ], [ [[TMP2]], [[COMPLEX_MUL_LIBCALL]] ]
// AARCH64-NEXT: [[IMAG_MUL_PHI:%.*]] = phi half [ [[MUL_I]], [[ENTRY]] ], [ [[MUL_I]], [[COMPLEX_MUL_IMAG_NAN]] ], [ [[TMP3]], [[COMPLEX_MUL_LIBCALL]] ]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[REAL_MUL_PHI]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[IMAG_MUL_PHI]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP4:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP4]]
//
_Float16 _Complex mul_float_cc(_Float16 _Complex a, _Float16 _Complex b) {
return a * b;
}
// AARCH64-LABEL: @div_float_rr(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[B_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: store half [[A:%.*]], half* [[A_ADDR]], align 2
// AARCH64-NEXT: store half [[B:%.*]], half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[TMP0:%.*]] = load half, half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[DIV:%.*]] = fdiv half [[TMP0]], [[TMP1]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[DIV]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half 0xH0000, half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP2]]
//
_Float16 _Complex div_float_rr(_Float16 a, _Float16 b) {
return a / b;
}
// AARCH64-LABEL: @div_float_cr(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[A]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[A_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: store half [[B:%.*]], half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[A_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 0
// AARCH64-NEXT: [[A_REAL:%.*]] = load half, half* [[A_REALP]], align 2
// AARCH64-NEXT: [[A_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 1
// AARCH64-NEXT: [[A_IMAG:%.*]] = load half, half* [[A_IMAGP]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[B_ADDR]], align 2
// AARCH64-NEXT: [[TMP2:%.*]] = fdiv half [[A_REAL]], [[TMP1]]
// AARCH64-NEXT: [[TMP3:%.*]] = fdiv half [[A_IMAG]], [[TMP1]]
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[TMP2]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[TMP3]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP4:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP4]]
//
_Float16 _Complex div_float_cr(_Float16 _Complex a, _Float16 b) {
return a / b;
}
// AARCH64-LABEL: @div_float_rc(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A_ADDR:%.*]] = alloca half, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[B]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[B_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: store half [[A:%.*]], half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = load half, half* [[A_ADDR]], align 2
// AARCH64-NEXT: [[B_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 0
// AARCH64-NEXT: [[B_REAL:%.*]] = load half, half* [[B_REALP]], align 2
// AARCH64-NEXT: [[B_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 1
// AARCH64-NEXT: [[B_IMAG:%.*]] = load half, half* [[B_IMAGP]], align 2
// AARCH64-NEXT: [[CALL:%.*]] = call { half, half } @__divhc3(half noundef [[TMP1]], half noundef 0xH0000, half noundef [[B_REAL]], half noundef [[B_IMAG]]) #[[ATTR1]]
// AARCH64-NEXT: [[TMP2:%.*]] = extractvalue { half, half } [[CALL]], 0
// AARCH64-NEXT: [[TMP3:%.*]] = extractvalue { half, half } [[CALL]], 1
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[TMP2]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[TMP3]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP4:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP4]]
//
_Float16 _Complex div_float_rc(_Float16 a, _Float16 _Complex b) {
return a / b;
}
// AARCH64-LABEL: @div_float_cc(
// AARCH64-NEXT: entry:
// AARCH64-NEXT: [[RETVAL:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[A:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[B:%.*]] = alloca { half, half }, align 2
// AARCH64-NEXT: [[TMP0:%.*]] = bitcast { half, half }* [[A]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[A_COERCE:%.*]], [2 x half]* [[TMP0]], align 2
// AARCH64-NEXT: [[TMP1:%.*]] = bitcast { half, half }* [[B]] to [2 x half]*
// AARCH64-NEXT: store [2 x half] [[B_COERCE:%.*]], [2 x half]* [[TMP1]], align 2
// AARCH64-NEXT: [[A_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 0
// AARCH64-NEXT: [[A_REAL:%.*]] = load half, half* [[A_REALP]], align 2
// AARCH64-NEXT: [[A_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[A]], i32 0, i32 1
// AARCH64-NEXT: [[A_IMAG:%.*]] = load half, half* [[A_IMAGP]], align 2
// AARCH64-NEXT: [[B_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 0
// AARCH64-NEXT: [[B_REAL:%.*]] = load half, half* [[B_REALP]], align 2
// AARCH64-NEXT: [[B_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[B]], i32 0, i32 1
// AARCH64-NEXT: [[B_IMAG:%.*]] = load half, half* [[B_IMAGP]], align 2
// AARCH64-NEXT: [[CALL:%.*]] = call { half, half } @__divhc3(half noundef [[A_REAL]], half noundef [[A_IMAG]], half noundef [[B_REAL]], half noundef [[B_IMAG]]) #[[ATTR1]]
// AARCH64-NEXT: [[TMP2:%.*]] = extractvalue { half, half } [[CALL]], 0
// AARCH64-NEXT: [[TMP3:%.*]] = extractvalue { half, half } [[CALL]], 1
// AARCH64-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 0
// AARCH64-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { half, half }, { half, half }* [[RETVAL]], i32 0, i32 1
// AARCH64-NEXT: store half [[TMP2]], half* [[RETVAL_REALP]], align 2
// AARCH64-NEXT: store half [[TMP3]], half* [[RETVAL_IMAGP]], align 2
// AARCH64-NEXT: [[TMP4:%.*]] = load { half, half }, { half, half }* [[RETVAL]], align 2
// AARCH64-NEXT: ret { half, half } [[TMP4]]
//
_Float16 _Complex div_float_cc(_Float16 _Complex a, _Float16 _Complex b) {
return a / b;
}