1 /* 2 * Copyright (c) 2021 - 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef ES2PANDA_COMPILER_CHECKER_ETS_WIDENING_CONVERTER_H 17 #define ES2PANDA_COMPILER_CHECKER_ETS_WIDENING_CONVERTER_H 18 19 #include "checker/ets/typeConverter.h" 20 #include "checker/ETSchecker.h" 21 22 namespace ark::es2panda::checker { 23 24 class WideningConverter : public TypeConverter { 25 public: WideningConverter(ETSChecker * checker,TypeRelation * relation,Type * target,Type * source)26 explicit WideningConverter(ETSChecker *checker, TypeRelation *relation, Type *target, Type *source) 27 : TypeConverter(checker, relation, target, source) 28 { 29 if (!Relation()->ApplyWidening()) { 30 return; 31 } 32 33 if (!Source()->HasTypeFlag(TypeFlag::CONSTANT)) { 34 ApplyGlobalWidening(); 35 } else { 36 ApplyConstWidening(); 37 } 38 } 39 40 private: 41 static constexpr TypeFlag WIDENABLE_TO_SHORT = TypeFlag::BYTE; 42 static constexpr TypeFlag WIDENABLE_TO_CHAR = TypeFlag::BYTE; 43 static constexpr TypeFlag WIDENABLE_TO_INT = TypeFlag::CHAR | TypeFlag::SHORT | WIDENABLE_TO_SHORT; 44 static constexpr TypeFlag WIDENABLE_TO_LONG = TypeFlag::INT | WIDENABLE_TO_INT; 45 static constexpr TypeFlag WIDENABLE_TO_FLOAT = TypeFlag::LONG | WIDENABLE_TO_LONG; 46 static constexpr TypeFlag WIDENABLE_TO_DOUBLE = TypeFlag::FLOAT | WIDENABLE_TO_FLOAT; 47 ApplyConstWidening()48 void ApplyConstWidening() 49 { 50 switch (ETSChecker::ETSChecker::ETSType(Target())) { 51 case TypeFlag::SHORT: { 52 ApplyWidening<ShortType>(WIDENABLE_TO_SHORT); 53 break; 54 } 55 case TypeFlag::INT: { 56 ApplyWidening<IntType>(WIDENABLE_TO_INT); 57 break; 58 } 59 case TypeFlag::LONG: { 60 ApplyWidening<LongType>(WIDENABLE_TO_LONG); 61 break; 62 } 63 case TypeFlag::FLOAT: { 64 ApplyWidening<FloatType>(WIDENABLE_TO_FLOAT); 65 break; 66 } 67 case TypeFlag::DOUBLE: { 68 ApplyWidening<DoubleType>(WIDENABLE_TO_DOUBLE); 69 break; 70 } 71 default: { 72 break; 73 } 74 } 75 } 76 ApplyGlobalWidening()77 void ApplyGlobalWidening() 78 { 79 switch (ETSChecker::ETSChecker::ETSType(Target())) { 80 case TypeFlag::CHAR: { 81 ApplyGlobalWidening(WIDENABLE_TO_CHAR); 82 break; 83 } 84 case TypeFlag::SHORT: { 85 ApplyGlobalWidening(WIDENABLE_TO_SHORT); 86 break; 87 } 88 case TypeFlag::INT: { 89 ApplyGlobalWidening(WIDENABLE_TO_INT); 90 break; 91 } 92 case TypeFlag::LONG: { 93 ApplyGlobalWidening(WIDENABLE_TO_LONG); 94 break; 95 } 96 case TypeFlag::FLOAT: { 97 ApplyGlobalWidening(WIDENABLE_TO_FLOAT); 98 break; 99 } 100 case TypeFlag::DOUBLE: { 101 ApplyGlobalWidening(WIDENABLE_TO_DOUBLE); 102 break; 103 } 104 default: { 105 break; 106 } 107 } 108 } 109 ApplyGlobalWidening(TypeFlag flag)110 void ApplyGlobalWidening(TypeFlag flag) 111 { 112 if (!Source()->HasTypeFlag(flag)) { 113 return; 114 } 115 116 if (!Relation()->OnlyCheckWidening()) { 117 ASSERT(Relation()->GetNode()); 118 switch (ETSChecker::ETSChecker::ETSType(Source())) { 119 case TypeFlag::BYTE: { 120 Relation()->GetNode()->SetTsType(Checker()->GlobalByteType()); 121 break; 122 } 123 case TypeFlag::SHORT: { 124 Relation()->GetNode()->SetTsType(Checker()->GlobalShortType()); 125 break; 126 } 127 case TypeFlag::CHAR: { 128 Relation()->GetNode()->SetTsType(Checker()->GlobalCharType()); 129 break; 130 } 131 case TypeFlag::INT: { 132 Relation()->GetNode()->SetTsType(Checker()->GlobalIntType()); 133 break; 134 } 135 case TypeFlag::LONG: { 136 Relation()->GetNode()->SetTsType(Checker()->GlobalLongType()); 137 break; 138 } 139 case TypeFlag::FLOAT: { 140 Relation()->GetNode()->SetTsType(Checker()->GlobalFloatType()); 141 break; 142 } 143 case TypeFlag::DOUBLE: { 144 Relation()->GetNode()->SetTsType(Checker()->GlobalDoubleType()); 145 break; 146 } 147 default: { 148 return; 149 } 150 } 151 } 152 153 Relation()->Result(true); 154 } 155 156 template <typename TargetType> ApplyWidening(TypeFlag flag)157 void ApplyWidening(TypeFlag flag) 158 { 159 if (!Source()->HasTypeFlag(flag)) { 160 return; 161 } 162 163 switch (ETSChecker::ETSChecker::ETSType(Source())) { 164 case TypeFlag::BYTE: { 165 ApplyWidening<TargetType, ByteType>(); 166 break; 167 } 168 case TypeFlag::CHAR: { 169 ApplyWidening<TargetType, CharType>(); 170 break; 171 } 172 case TypeFlag::SHORT: { 173 ApplyWidening<TargetType, ShortType>(); 174 break; 175 } 176 case TypeFlag::INT: { 177 ApplyWidening<TargetType, IntType>(); 178 break; 179 } 180 case TypeFlag::LONG: { 181 ApplyWidening<TargetType, LongType>(); 182 break; 183 } 184 case TypeFlag::FLOAT: { 185 ApplyWidening<TargetType, FloatType>(); 186 break; 187 } 188 case TypeFlag::DOUBLE: { 189 ApplyWidening<TargetType, DoubleType>(); 190 break; 191 } 192 default: { 193 return; 194 } 195 } 196 Relation()->Result(true); 197 } 198 199 template <typename TargetType, typename SourceType> ApplyWidening()200 void ApplyWidening() 201 { 202 using SType = typename SourceType::UType; 203 using TType = typename TargetType::UType; 204 SType value = reinterpret_cast<SourceType *>(Source())->GetValue(); 205 206 if (!Relation()->OnlyCheckWidening()) { 207 ASSERT(Relation()->GetNode()); 208 Relation()->GetNode()->SetTsType(Checker()->Allocator()->New<TargetType>(static_cast<TType>(value))); 209 } 210 } 211 }; 212 } // namespace ark::es2panda::checker 213 214 #endif 215