Skip to content

Commit a379f19

Browse files
amykhuangamykhuang
committed
Bitcast in _Copy functions and update test
1 parent a60608a commit a379f19

File tree

3 files changed

+66
-81
lines changed

3 files changed

+66
-81
lines changed

‎clang/include/clang/Basic/BuiltinsAArch64.def

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -274,13 +274,13 @@ TARGET_HEADER_BUILTIN(_CopyFloatFromInt32, "fSi", "nh", INTRIN_H, ALL_MS_LANGUAG
274274
TARGET_HEADER_BUILTIN(_CopyInt32FromFloat, "Sif", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
275275
TARGET_HEADER_BUILTIN(_CopyInt64FromDouble, "SLLid", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
276276

277-
TARGET_HEADER_BUILTIN(_CountLeadingOnes, "UiULi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
277+
TARGET_HEADER_BUILTIN(_CountLeadingOnes, "UiUNi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
278278
TARGET_HEADER_BUILTIN(_CountLeadingOnes64, "UiULLi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
279-
TARGET_HEADER_BUILTIN(_CountLeadingSigns, "UiSLi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
279+
TARGET_HEADER_BUILTIN(_CountLeadingSigns, "UiSNi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
280280
TARGET_HEADER_BUILTIN(_CountLeadingSigns64, "UiSLLi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
281-
TARGET_HEADER_BUILTIN(_CountLeadingZeros, "UiULi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
281+
TARGET_HEADER_BUILTIN(_CountLeadingZeros, "UiUNi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
282282
TARGET_HEADER_BUILTIN(_CountLeadingZeros64, "UiULLi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
283-
TARGET_HEADER_BUILTIN(_CountOneBits, "UiULi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
283+
TARGET_HEADER_BUILTIN(_CountOneBits, "UiUNi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
284284
TARGET_HEADER_BUILTIN(_CountOneBits64, "UiULLi", "nh", INTRIN_H, ALL_MS_LANGUAGES, "")
285285

286286
#undef BUILTIN

‎clang/lib/CodeGen/CGBuiltin.cpp

Lines changed: 5 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -10785,13 +10785,7 @@ Value *CodeGenFunction::EmitAArch64BuiltinExpr(unsigned BuiltinID,
1078510785
BuiltinID == AArch64::BI_CopyInt64FromDouble) {
1078610786
Value *Arg = EmitScalarExpr(E->getArg(0));
1078710787
llvm::Type *RetTy = ConvertType(E->getType());
10788-
10789-
if (BuiltinID == AArch64::BI_CopyDoubleFromInt64 ||
10790-
BuiltinID == AArch64::BI_CopyFloatFromInt32)
10791-
Arg = Builder.CreateSIToFP(Arg, RetTy);
10792-
else
10793-
Arg = Builder.CreateFPToSI(Arg, RetTy);
10794-
return Arg;
10788+
return Builder.CreateBitCast(Arg, RetTy);
1079510789
}
1079610790

1079710791
if (BuiltinID == AArch64::BI_CountLeadingOnes ||
@@ -10817,20 +10811,11 @@ Value *CodeGenFunction::EmitAArch64BuiltinExpr(unsigned BuiltinID,
1081710811
if (BuiltinID == AArch64::BI_CountLeadingSigns ||
1081810812
BuiltinID == AArch64::BI_CountLeadingSigns64) {
1081910813
Value *Arg = EmitScalarExpr(E->getArg(0));
10820-
llvm::Type *ArgType = Arg->getType();
1082110814

10822-
Function *F;
10823-
if (BuiltinID == AArch64::BI_CountLeadingSigns) {
10824-
F = CGM.getIntrinsic(Intrinsic::aarch64_cls);
10825-
if (ArgType != Builder.getInt32Ty())
10826-
Arg =
10827-
Builder.CreateIntCast(Arg, Builder.getInt32Ty(), /*isSigned*/ true);
10828-
} else {
10829-
F = CGM.getIntrinsic(Intrinsic::aarch64_cls64);
10830-
if (ArgType != Builder.getInt64Ty())
10831-
Arg =
10832-
Builder.CreateIntCast(Arg, Builder.getInt64Ty(), /*isSigned*/ true);
10833-
}
10815+
Function *F = (BuiltinID == AArch64::BI_CountLeadingSigns)
10816+
? CGM.getIntrinsic(Intrinsic::aarch64_cls)
10817+
: CGM.getIntrinsic(Intrinsic::aarch64_cls64);
10818+
1083410819
Value *Result = Builder.CreateCall(F, Arg, "cls");
1083510820
if (BuiltinID == AArch64::BI_CountLeadingSigns64)
1083610821
Result = Builder.CreateTrunc(Result, Builder.getInt32Ty());

‎clang/test/CodeGen/arm64-microsoft-intrinsics.c

Lines changed: 57 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -269,138 +269,138 @@ double check__CopyDoubleFromInt64(__int64 arg1) {
269269
return _CopyDoubleFromInt64(arg1);
270270
}
271271

272-
// CHECK-MSCOMPAT: %[[RETVAL:.*]] = alloca double, align 8
273272
// CHECK-MSCOMPAT: %[[ARG:.*]].addr = alloca i64, align 8
274273
// CHECK-MSCOMPAT: store i64 %[[ARG]], ptr %[[ARG]].addr, align 8
275274
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load i64, ptr %[[ARG]].addr, align 8
276-
// CHECK-MSCOMPAT: store i64 %[[VAR0]], ptr %[[RETVAL]], align 8
277-
// CHECK-MSCOMPAT: %[[VAR1:.*]] = load double, ptr %[[RETVAL]], align 8
275+
// CHECK-MSCOMPAT: %[[VAR1:.*]] = bitcast i64 %[[VAR0]] to double
278276
// CHECK-MSCOMPAT: ret double %[[VAR1]]
279277
// CHECK-LINUX: error: call to undeclared function '_CopyDoubleFromInt64'
280278

281279
float check__CopyFloatFromInt32(__int32 arg1) {
282280
return _CopyFloatFromInt32(arg1);
283281
}
284282

285-
// CHECK-MSCOMPAT: %[[RETVAL:.*]] = alloca float, align 4
286283
// CHECK-MSCOMPAT: %[[ARG:.*]].addr = alloca i32, align 4
287284
// CHECK-MSCOMPAT: store i32 %[[ARG]], ptr %[[ARG]].addr, align 4
288285
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load i32, ptr %[[ARG]].addr, align 4
289-
// CHECK-MSCOMPAT: store i32 %[[VAR0]], ptr %[[RETVAL]], align 4
290-
// CHECK-MSCOMPAT: %[[VAR1:.*]] = load float, ptr %[[RETVAL]], align 4
286+
// CHECK-MSCOMPAT: %[[VAR1:.*]] = bitcast i32 %[[VAR0]] to float
291287
// CHECK-MSCOMPAT: ret float %[[VAR1]]
292288
// CHECK-LINUX: error: call to undeclared function '_CopyFloatFromInt32'
293289

294290
__int32 check__CopyInt32FromFloat(float arg1) {
295291
return _CopyInt32FromFloat(arg1);
296292
}
297293

298-
// CHECK-MSCOMPAT: %[[RETVAL:.*]] = alloca i32, align 4
299294
// CHECK-MSCOMPAT: %[[ARG:.*]].addr = alloca float, align 4
300295
// CHECK-MSCOMPAT: store float %[[ARG]], ptr %[[ARG]].addr, align 4
301296
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load float, ptr %[[ARG]].addr, align 4
302-
// CHECK-MSCOMPAT: store float %[[VAR0]], ptr %[[RETVAL]], align 4
303-
// CHECK-MSCOMPAT: %[[VAR1:.*]] = load i32, ptr %[[RETVAL]], align 4
297+
// CHECK-MSCOMPAT: %[[VAR1:.*]] = bitcast float %[[VAR0]] to i32
304298
// CHECK-MSCOMPAT: ret i32 %[[VAR1]]
305299
// CHECK-LINUX: error: call to undeclared function '_CopyInt32FromFloat'
306300

307301
__int64 check__CopyInt64FromDouble(double arg1) {
308302
return _CopyInt64FromDouble(arg1);
309303
}
310304

311-
// CHECK-MSCOMPAT: %[[RETVAL:.*]] = alloca i64, align 8
312305
// CHECK-MSCOMPAT: %[[ARG:.*]].addr = alloca double, align 8
313306
// CHECK-MSCOMPAT: store double %[[ARG]], ptr %[[ARG]].addr, align 8
314307
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load double, ptr %[[ARG]].addr, align 8
315-
// CHECK-MSCOMPAT: store double %[[VAR0]], ptr %[[RETVAL]], align 8
316-
// CHECK-MSCOMPAT: %[[VAR1:.*]] = load i64, ptr %[[RETVAL]], align 8
308+
// CHECK-MSCOMPAT: %[[VAR1:.*]] = bitcast double %[[VAR0]] to i64
317309
// CHECK-MSCOMPAT: ret i64 %[[VAR1]]
318310
// CHECK-LINUX: error: call to undeclared function '_CopyInt64FromDouble'
319311

320312
unsigned int check__CountLeadingOnes(unsigned LONG arg1) {
321313
return _CountLeadingOnes(arg1);
322314
}
323315

324-
// CHECK-MSVC: %[[ARG1:.*]].addr = alloca i32, align 4
325-
// CHECK-MSVC: store i32 %[[ARG1]], ptr %[[ARG1]].addr, align 4
326-
// CHECK-MSVC: %[[VAR0:.*]] = load i32, ptr %[[ARG1]].addr, align 4
327-
// CHECK-MSVC: %[[VAR1:.*]] = xor i32 %[[VAR0]], -1
328-
// CHECK-MSVC: %[[VAR2:.*]] = call i32 @llvm.ctlz.i32(i32 %1, i1 false)
329-
// CHECK-MSVC: ret i32 %[[VAR2]]
316+
// CHECK-MSCOMPAT: %[[ARG1:.*]].addr = alloca i32, align 4
317+
// CHECK-MSCOMPAT: store i32 %[[ARG1]], ptr %[[ARG1]].addr, align 4
318+
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load i32, ptr %[[ARG1]].addr, align 4
319+
// CHECK-MSCOMPAT: %[[VAR1:.*]] = xor i32 %[[VAR0]], -1
320+
// CHECK-MSCOMPAT: %[[VAR2:.*]] = call i32 @llvm.ctlz.i32(i32 %1, i1 false)
321+
// CHECK-MSCOMPAT: ret i32 %[[VAR2]]
322+
// CHECK-LINUX: error: call to undeclared function '_CountLeadingOnes'
330323

331324
unsigned int check__CountLeadingOnes64(unsigned __int64 arg1) {
332325
return _CountLeadingOnes64(arg1);
333326
}
334327

335-
// CHECK-MSVC: %[[ARG1:.*]].addr = alloca i64, align 8
336-
// CHECK-MSVC: store i64 %[[ARG1]], ptr %[[ARG1]].addr, align 8
337-
// CHECK-MSVC: %[[VAR0:.*]] = load i64, ptr %[[ARG1]].addr, align 8
338-
// CHECK-MSVC: %[[VAR1:.*]] = xor i64 %[[VAR0]], -1
339-
// CHECK-MSVC: %[[VAR2:.*]] = call i64 @llvm.ctlz.i64(i64 %1, i1 false)
340-
// CHECK-MSVC: %[[VAR3:.*]] = trunc i64 %2 to i32
341-
// CHECK-MSVC: ret i32 %[[VAR3]]
328+
// CHECK-MSCOMPAT: %[[ARG1:.*]].addr = alloca i64, align 8
329+
// CHECK-MSCOMPAT: store i64 %[[ARG1]], ptr %[[ARG1]].addr, align 8
330+
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load i64, ptr %[[ARG1]].addr, align 8
331+
// CHECK-MSCOMPAT: %[[VAR1:.*]] = xor i64 %[[VAR0]], -1
332+
// CHECK-MSCOMPAT: %[[VAR2:.*]] = call i64 @llvm.ctlz.i64(i64 %1, i1 false)
333+
// CHECK-MSCOMPAT: %[[VAR3:.*]] = trunc i64 %2 to i32
334+
// CHECK-MSCOMPAT: ret i32 %[[VAR3]]
335+
// CHECK-LINUX: error: call to undeclared function '_CountLeadingOnes64'
342336

343337
unsigned int check__CountLeadingSigns(__int32 arg1) {
344338
return _CountLeadingSigns(arg1);
345339
}
346340

347-
// CHECK-MSVC: %[[ARG1:.*]].addr = alloca i32, align 4
348-
// CHECK-MSVC: store i32 %[[ARG1]], ptr %[[ARG1]].addr, align 4
349-
// CHECK-MSVC: %[[VAR0:.*]] = load i32, ptr %[[ARG1]].addr, align 4
350-
// CHECK-MSVC: %[[CLS:.*]] = call i32 @llvm.aarch64.cls(i32 %[[VAR0]])
351-
// CHECK-MSVC: ret i32 %[[CLS]]
341+
// CHECK-MSCOMPAT: %[[ARG1:.*]].addr = alloca i32, align 4
342+
// CHECK-MSCOMPAT: store i32 %[[ARG1]], ptr %[[ARG1]].addr, align 4
343+
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load i32, ptr %[[ARG1]].addr, align 4
344+
// CHECK-MSCOMPAT: %[[CLS:.*]] = call i32 @llvm.aarch64.cls(i32 %[[VAR0]])
345+
// CHECK-MSCOMPAT: ret i32 %[[CLS]]
346+
// CHECK-LINUX: error: call to undeclared function '_CountLeadingSigns'
352347

353348
unsigned int check__CountLeadingSigns64(__int64 arg1) {
354349
return _CountLeadingSigns64(arg1);
355350
}
356351

357-
// CHECK-MSVC: %[[ARG1:.*]].addr = alloca i64, align 8
358-
// CHECK-MSVC: store i64 %[[ARG1]], ptr %[[ARG1]].addr, align 8
359-
// CHECK-MSVC: %[[VAR0:.*]] = load i64, ptr %[[ARG1]].addr, align 8
360-
// CHECK-MSVC: %[[CLS:.*]] = call i32 @llvm.aarch64.cls64(i64 %[[VAR0]])
361-
// CHECK-MSVC: ret i32 %[[CLS]]
352+
// CHECK-MSCOMPAT: %[[ARG1:.*]].addr = alloca i64, align 8
353+
// CHECK-MSCOMPAT: store i64 %[[ARG1]], ptr %[[ARG1]].addr, align 8
354+
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load i64, ptr %[[ARG1]].addr, align 8
355+
// CHECK-MSCOMPAT: %[[CLS:.*]] = call i32 @llvm.aarch64.cls64(i64 %[[VAR0]])
356+
// CHECK-MSCOMPAT: ret i32 %[[CLS]]
357+
// CHECK-LINUX: error: call to undeclared function '_CountLeadingSigns64'
362358

363359
unsigned int check__CountLeadingZeros(__int32 arg1) {
364360
return _CountLeadingZeros(arg1);
365361
}
366362

367-
// CHECK-MSVC: %[[ARG1:.*]].addr = alloca i32, align 4
368-
// CHECK-MSVC: store i32 %[[ARG1]], ptr %[[ARG1]].addr, align 4
369-
// CHECK-MSVC: %[[VAR0:.*]] = load i32, ptr %[[ARG1]].addr, align 4
370-
// CHECK-MSVC: %[[VAR1:.*]] = call i32 @llvm.ctlz.i32(i32 %[[VAR0]], i1 false)
371-
// CHECK-MSVC: ret i32 %[[VAR1]]
363+
// CHECK-MSCOMPAT: %[[ARG1:.*]].addr = alloca i32, align 4
364+
// CHECK-MSCOMPAT: store i32 %[[ARG1]], ptr %[[ARG1]].addr, align 4
365+
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load i32, ptr %[[ARG1]].addr, align 4
366+
// CHECK-MSCOMPAT: %[[VAR1:.*]] = call i32 @llvm.ctlz.i32(i32 %[[VAR0]], i1 false)
367+
// CHECK-MSCOMPAT: ret i32 %[[VAR1]]
368+
// CHECK-LINUX: error: call to undeclared function '_CountLeadingZeros'
372369

373370
unsigned int check__CountLeadingZeros64(__int64 arg1) {
374371
return _CountLeadingZeros64(arg1);
375372
}
376373

377-
// CHECK-MSVC: %[[ARG1:.*]].addr = alloca i64, align 8
378-
// CHECK-MSVC: store i64 %[[ARG1]], ptr %[[ARG1]].addr, align 8
379-
// CHECK-MSVC: %[[VAR0:.*]] = load i64, ptr %[[ARG1]].addr, align 8
380-
// CHECK-MSVC: %[[VAR1:.*]] = call i64 @llvm.ctlz.i64(i64 %[[VAR0]], i1 false)
381-
// CHECK-MSVC: %[[VAR2:.*]] = trunc i64 %[[VAR1]] to i32
382-
// CHECK-MSVC: ret i32 %[[VAR2]]
374+
// CHECK-MSCOMPAT: %[[ARG1:.*]].addr = alloca i64, align 8
375+
// CHECK-MSCOMPAT: store i64 %[[ARG1]], ptr %[[ARG1]].addr, align 8
376+
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load i64, ptr %[[ARG1]].addr, align 8
377+
// CHECK-MSCOMPAT: %[[VAR1:.*]] = call i64 @llvm.ctlz.i64(i64 %[[VAR0]], i1 false)
378+
// CHECK-MSCOMPAT: %[[VAR2:.*]] = trunc i64 %[[VAR1]] to i32
379+
// CHECK-MSCOMPAT: ret i32 %[[VAR2]]
380+
// CHECK-LINUX: error: call to undeclared function '_CountLeadingZeros64'
383381

384382
unsigned int check_CountOneBits(unsigned LONG arg1) {
385383
return _CountOneBits(arg1);
386384
}
387385

388-
// CHECK-MSVC: %[[ARG1:.*]].addr = alloca i32, align 4
389-
// CHECK-MSVC: store i32 %[[ARG1]], ptr %[[ARG1]].addr, align 4
390-
// CHECK-MSVC: %[[VAR0:.*]] = load i32, ptr %[[ARG1]].addr, align 4
391-
// CHECK-MSVC: %[[VAR1:.*]] = call i32 @llvm.ctpop.i32(i32 %0)
392-
// CHECK-MSVC: ret i32 %[[VAR1]]
386+
// CHECK-MSCOMPAT: %[[ARG1:.*]].addr = alloca i32, align 4
387+
// CHECK-MSCOMPAT: store i32 %[[ARG1]], ptr %[[ARG1]].addr, align 4
388+
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load i32, ptr %[[ARG1]].addr, align 4
389+
// CHECK-MSCOMPAT: %[[VAR1:.*]] = call i32 @llvm.ctpop.i32(i32 %0)
390+
// CHECK-MSCOMPAT: ret i32 %[[VAR1]]
391+
// CHECK-LINUX: error: call to undeclared function '_CountOneBits'
393392

394393
unsigned int check_CountOneBits64(unsigned __int64 arg1) {
395394
return _CountOneBits64(arg1);
396395
}
397396

398-
// CHECK-MSVC: %[[ARG1:.*]].addr = alloca i64, align 8
399-
// CHECK-MSVC: store i64 %[[ARG1]], ptr %[[ARG1]].addr, align 8
400-
// CHECK-MSVC: %[[VAR0:.*]] = load i64, ptr %[[ARG1]].addr, align 8
401-
// CHECK-MSVC: %[[VAR1:.*]] = call i64 @llvm.ctpop.i64(i64 %0)
402-
// CHECK-MSVC: %[[VAR2:.*]] = trunc i64 %1 to i32
403-
// CHECK-MSVC: ret i32 %[[VAR2]]
397+
// CHECK-MSCOMPAT: %[[ARG1:.*]].addr = alloca i64, align 8
398+
// CHECK-MSCOMPAT: store i64 %[[ARG1]], ptr %[[ARG1]].addr, align 8
399+
// CHECK-MSCOMPAT: %[[VAR0:.*]] = load i64, ptr %[[ARG1]].addr, align 8
400+
// CHECK-MSCOMPAT: %[[VAR1:.*]] = call i64 @llvm.ctpop.i64(i64 %0)
401+
// CHECK-MSCOMPAT: %[[VAR2:.*]] = trunc i64 %1 to i32
402+
// CHECK-MSCOMPAT: ret i32 %[[VAR2]]
403+
// CHECK-LINUX: error: call to undeclared function '_CountOneBits64'
404404

405405

406406
// CHECK-MSCOMPAT: ![[MD2]] = !{!"x18"}

0 commit comments

Comments
 (0)