test/CodeGen/ms-x86-intrinsics.c

   1 // RUN: %clang_cc1 -ffreestanding -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \
   2 // RUN:         -triple i686--windows -Oz -emit-llvm %s -o - \
   3 // RUN:         | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-I386
   4 // RUN: %clang_cc1 -ffreestanding -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \
   5 // RUN:         -triple x86_64--windows -Oz -emit-llvm %s -o - \
   6 // RUN:         | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-X64
   7
   8 #if defined(__i386__)
   9 char test__readfsbyte(unsigned long Offset) {
  10   return __readfsbyte(Offset);
  11 }
  12 // CHECK-I386-LABEL: define signext i8 @test__readfsbyte(i32 %Offset)
  13 // CHECK-I386:   [[PTR:%[0-9]+]] = inttoptr i32 %Offset to i8 addrspace(257)*
  14 // CHECK-I386:   [[VALUE:%[0-9]+]] = load volatile i8, i8 addrspace(257)* [[PTR]], align 1
  15 // CHECK-I386:   ret i8 [[VALUE:%[0-9]+]]
  16
  17 short test__readfsword(unsigned long Offset) {
  18   return __readfsword(Offset);
  19 }
  20 // CHECK-I386-LABEL: define signext i16 @test__readfsword(i32 %Offset)
  21 // CHECK-I386:   [[PTR:%[0-9]+]] = inttoptr i32 %Offset to i16 addrspace(257)*
  22 // CHECK-I386:   [[VALUE:%[0-9]+]] = load volatile i16, i16 addrspace(257)* [[PTR]], align 2
  23 // CHECK-I386:   ret i16 [[VALUE:%[0-9]+]]
  24
  25 long test__readfsdword(unsigned long Offset) {
  26   return __readfsdword(Offset);
  27 }
  28 // CHECK-I386-LABEL: define i32 @test__readfsdword(i32 %Offset)
  29 // CHECK-I386:   [[PTR:%[0-9]+]] = inttoptr i32 %Offset to i32 addrspace(257)*
  30 // CHECK-I386:   [[VALUE:%[0-9]+]] = load volatile i32, i32 addrspace(257)* [[PTR]], align 4
  31 // CHECK-I386:   ret i32 [[VALUE:%[0-9]+]]
  32
  33 long long test__readfsqword(unsigned long Offset) {
  34   return __readfsqword(Offset);
  35 }
  36 // CHECK-I386-LABEL: define i64 @test__readfsqword(i32 %Offset)
  37 // CHECK-I386:   [[PTR:%[0-9]+]] = inttoptr i32 %Offset to i64 addrspace(257)*
  38 // CHECK-I386:   [[VALUE:%[0-9]+]] = load volatile i64, i64 addrspace(257)* [[PTR]], align 8
  39 // CHECK-I386:   ret i64 [[VALUE:%[0-9]+]]
  40 #endif
  41
  42 __int64 test__emul(int a, int b) {
  43   return __emul(a, b);
  44 }
  45 // CHECK-LABEL: define i64 @test__emul(i32 %a, i32 %b)
  46 // CHECK: [[X:%[0-9]+]] = sext i32 %a to i64
  47 // CHECK: [[Y:%[0-9]+]] = sext i32 %b to i64
  48 // CHECK: [[RES:%[0-9]+]] = mul nsw i64 [[Y]], [[X]]
  49 // CHECK: ret i64 [[RES]]
  50
  51 unsigned __int64 test__emulu(unsigned int a, unsigned int b) {
  52   return __emulu(a, b);
  53 }
  54 // CHECK-LABEL: define i64 @test__emulu(i32 %a, i32 %b)
  55 // CHECK: [[X:%[0-9]+]] = zext i32 %a to i64
  56 // CHECK: [[Y:%[0-9]+]] = zext i32 %b to i64
  57 // CHECK: [[RES:%[0-9]+]] = mul nuw i64 [[Y]], [[X]]
  58 // CHECK: ret i64 [[RES]]
  59
  60 #if defined(__x86_64__)
  61
  62 char test__readgsbyte(unsigned long Offset) {
  63   return __readgsbyte(Offset);
  64 }
  65 // CHECK-X64-LABEL: define i8 @test__readgsbyte(i32 %Offset)
  66 // CHECK-X64:   [[ZEXT:%[0-9]+]] = zext i32 %Offset to i64
  67 // CHECK-X64:   [[PTR:%[0-9]+]] = inttoptr i64 [[ZEXT]] to i8 addrspace(256)*
  68 // CHECK-X64:   [[VALUE:%[0-9]+]] = load volatile i8, i8 addrspace(256)* [[PTR]], align 1
  69 // CHECK-X64:   ret i8 [[VALUE:%[0-9]+]]
  70
  71 short test__readgsword(unsigned long Offset) {
  72   return __readgsword(Offset);
  73 }
  74 // CHECK-X64-LABEL: define i16 @test__readgsword(i32 %Offset)
  75 // CHECK-X64:   [[ZEXT:%[0-9]+]] = zext i32 %Offset to i64
  76 // CHECK-X64:   [[PTR:%[0-9]+]] = inttoptr i64 [[ZEXT]] to i16 addrspace(256)*
  77 // CHECK-X64:   [[VALUE:%[0-9]+]] = load volatile i16, i16 addrspace(256)* [[PTR]], align 2
  78 // CHECK-X64:   ret i16 [[VALUE:%[0-9]+]]
  79
  80 long test__readgsdword(unsigned long Offset) {
  81   return __readgsdword(Offset);
  82 }
  83 // CHECK-X64-LABEL: define i32 @test__readgsdword(i32 %Offset)
  84 // CHECK-X64:   [[ZEXT:%[0-9]+]] = zext i32 %Offset to i64
  85 // CHECK-X64:   [[PTR:%[0-9]+]] = inttoptr i64 [[ZEXT]] to i32 addrspace(256)*
  86 // CHECK-X64:   [[VALUE:%[0-9]+]] = load volatile i32, i32 addrspace(256)* [[PTR]], align 4
  87 // CHECK-X64:   ret i32 [[VALUE:%[0-9]+]]
  88
  89 long long test__readgsqword(unsigned long Offset) {
  90   return __readgsqword(Offset);
  91 }
  92 // CHECK-X64-LABEL: define i64 @test__readgsqword(i32 %Offset)
  93 // CHECK-X64:   [[ZEXT:%[0-9]+]] = zext i32 %Offset to i64
  94 // CHECK-X64:   [[PTR:%[0-9]+]] = inttoptr i64 [[ZEXT]] to i64 addrspace(256)*
  95 // CHECK-X64:   [[VALUE:%[0-9]+]] = load volatile i64, i64 addrspace(256)* [[PTR]], align 8
  96 // CHECK-X64:   ret i64 [[VALUE:%[0-9]+]]
  97
  98 __int64 test__mulh(__int64 a, __int64 b) {
  99   return __mulh(a, b);
 100 }
 101 // CHECK-X64-LABEL: define i64 @test__mulh(i64 %a, i64 %b)
 102 // CHECK-X64: = mul nsw i128 %
 103
 104 unsigned __int64 test__umulh(unsigned __int64 a, unsigned __int64 b) {
 105   return __umulh(a, b);
 106 }
 107 // CHECK-X64-LABEL: define i64 @test__umulh(i64 %a, i64 %b)
 108 // CHECK-X64: = mul nuw i128 %
 109
 110 __int64 test_mul128(__int64 Multiplier,
 111                     __int64 Multiplicand,
 112                     __int64 *HighProduct) {
 113   return _mul128(Multiplier, Multiplicand, HighProduct);
 114 }
 115 // CHECK-X64-LABEL: define i64 @test_mul128(i64 %Multiplier, i64 %Multiplicand, i64*{{[a-z_ ]*}}%HighProduct)
 116 // CHECK-X64: = sext i64 %Multiplier to i128
 117 // CHECK-X64: = sext i64 %Multiplicand to i128
 118 // CHECK-X64: = mul nsw i128 %
 119 // CHECK-X64: store i64 %
 120 // CHECK-X64: ret i64 %
 121
 122 unsigned __int64 test_umul128(unsigned __int64 Multiplier,
 123                               unsigned __int64 Multiplicand,
 124                               unsigned __int64 *HighProduct) {
 125   return _umul128(Multiplier, Multiplicand, HighProduct);
 126 }
 127 // CHECK-X64-LABEL: define i64 @test_umul128(i64 %Multiplier, i64 %Multiplicand, i64*{{[a-z_ ]*}}%HighProduct)
 128 // CHECK-X64: = zext i64 %Multiplier to i128
 129 // CHECK-X64: = zext i64 %Multiplicand to i128
 130 // CHECK-X64: = mul nuw i128 %
 131 // CHECK-X64: store i64 %
 132 // CHECK-X64: ret i64 %
 133 #endif