Debian Codegraph @

visa/iga/IGALibrary/IR/ImmVal.cpp

raw
1 /*========================== begin_copyright_notice ============================
2
3 Copyright (C) 2017-2021 Intel Corporation
4
5 SPDX-License-Identifier: MIT
6
7 ============================= end_copyright_notice ===========================*/
8
9 #include "ImmVal.hpp"
10 #include "../Frontend/Floats.hpp"
11
12 #include <cmath>
13
14 using namespace iga;
15
16 ImmVal &ImmVal::operator=(uint8_t x) {
17 kind = Kind::U8;
18 u64 = 0;
19 u8 = x;
20 return *this;
21 }
22 ImmVal &ImmVal::operator=(int8_t x) {
23 kind = Kind::S8;
24 u64 = 0;
25 s8 = x;
26 return *this;
27 }
28 ImmVal &ImmVal::operator=(uint16_t x) {
29 kind = Kind::U16;
30 u64 = 0;
31 u16 = x;
32 return *this;
33 }
34 ImmVal &ImmVal::operator=(int16_t x) {
35 kind = Kind::S16;
36 u64 = 0;
37 s16 = x;
38 return *this;
39 }
40 ImmVal &ImmVal::operator=(uint32_t x) {
41 kind = Kind::U32;
42 u64 = 0;
43 u32 = x;
44 return *this;
45 }
46 ImmVal &ImmVal::operator=(int32_t x) {
47 kind = Kind::S32;
48 u64 = 0;
49 s32 = x;
50 return *this;
51 }
52 ImmVal &ImmVal::operator=(uint64_t x) {
53 kind = Kind::U64;
54 u64 = x;
55 return *this;
56 }
57 ImmVal &ImmVal::operator=(int64_t x) {
58 kind = Kind::S64;
59 s64 = x;
60 return *this;
61 }
62 ImmVal &ImmVal::operator=(float x) {
63 kind = Kind::F32;
64 u64 = 0;
65 f32 = x;
66 return *this;
67 }
68 ImmVal &ImmVal::operator=(double x) {
69 kind = Kind::F64;
70 f64 = x;
71 return *this;
72 }
73
74 void ImmVal::Abs() {
75 switch (kind) {
76 case Kind::F16:
77 // the sign bit manually so that we can "negate" NaN values
78 u16 &= ~F16_SIGN_BIT;
79 break;
80 case Kind::F32:
81 // see F16
82 u32 &= ~F32_SIGN_BIT;
83 break;
84 case Kind::F64:
85 // see F64
86 u64 &= ~F64_SIGN_BIT;
87 break;
88
89 case Kind::S8:
90 s8 = s8 < 0 ? -s8 : s8;
91 break;
92 case Kind::S16:
93 s32 = s16 < 0 ? -s16 : s16;
94 break;
95 case Kind::S32:
96 s32 = s32 < 0 ? -s32 : s32;
97 break;
98 case Kind::S64:
99 s64 = s64 < 0 ? -s64 : s64;
100 break;
101 default:
102 break;
103 }
104 }
105
106 void ImmVal::Negate() {
107 switch (kind) {
108 case Kind::F16:
109 // N.B. we manually flip the sign bit
110 // so that -{s,q}nan gives the right bit pattern on all HW
111 u16 = F16_SIGN_BIT ^ u16;
112 break;
113 case Kind::F32:
114 // see above
115 u32 = F32_SIGN_BIT ^ u32;
116 break;
117 case Kind::F64:
118 // see above
119 u64 = F64_SIGN_BIT ^ u64;
120 break;
121
122 case Kind::S8:
123 s8 = -s8;
124 break;
125 case Kind::S16:
126 s16 = -s16;
127 break;
128 case Kind::S32:
129 s32 = -s32;
130 break;
131 case Kind::S64:
132 s64 = -s64;
133 break;
134 default:
135 break;
136 }
137 }