1 // Copyright 2016 The SwiftShader Authors. All Rights Reserved. 2 // 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 #ifndef sw_Reactor_hpp 16 #define sw_Reactor_hpp 17 18 #include "Nucleus.hpp" 19 #include "Routine.hpp" 20 21 #include <cassert> 22 #include <cstddef> 23 #include <cwchar> 24 #undef Bool 25 26 namespace sw 27 { 28 class Bool; 29 class Byte; 30 class SByte; 31 class Byte4; 32 class SByte4; 33 class Byte8; 34 class SByte8; 35 class Byte16; 36 class SByte16; 37 class Short; 38 class UShort; 39 class Short2; 40 class UShort2; 41 class Short4; 42 class UShort4; 43 class Short8; 44 class UShort8; 45 class Int; 46 class UInt; 47 class Int2; 48 class UInt2; 49 class Int4; 50 class UInt4; 51 class Long; 52 class Float; 53 class Float2; 54 class Float4; 55 56 class Void 57 { 58 public: 59 static Type *getType(); 60 61 static bool isVoid() 62 { 63 return true; 64 } 65 }; 66 67 template<class T> 68 class RValue; 69 70 template<class T> 71 class Pointer; 72 73 class Variable 74 { 75 protected: 76 Value *address; 77 }; 78 79 template<class T> 80 class LValue : public Variable 81 { 82 public: 83 LValue(int arraySize = 0); 84 85 RValue<Pointer<T>> operator&(); 86 87 static bool isVoid() 88 { 89 return false; 90 } 91 92 Value *loadValue() const; 93 Value *storeValue(Value *value) const; 94 Value *getAddress(Value *index, bool unsignedIndex) const; 95 }; 96 97 template<class T> 98 class Reference 99 { 100 public: 101 explicit Reference(Value *pointer, int alignment = 1); 102 103 RValue<T> operator=(RValue<T> rhs) const; 104 RValue<T> operator=(const Reference<T> &ref) const; 105 106 RValue<T> operator+=(RValue<T> rhs) const; 107 108 Value *loadValue() const; 109 int getAlignment() const; 110 111 private: 112 Value *address; 113 114 const int alignment; 115 }; 116 117 template<class T> 118 struct IntLiteral 119 { 120 struct type; 121 }; 122 123 template<> 124 struct IntLiteral<Bool> 125 { 126 typedef bool type; 127 }; 128 129 template<> 130 struct IntLiteral<Int> 131 { 132 typedef int type; 133 }; 134 135 template<> 136 struct IntLiteral<UInt> 137 { 138 typedef unsigned int type; 139 }; 140 141 template<> 142 struct IntLiteral<Long> 143 { 144 typedef int64_t type; 145 }; 146 147 template<class T> 148 struct FloatLiteral 149 { 150 struct type; 151 }; 152 153 template<> 154 struct FloatLiteral<Float> 155 { 156 typedef float type; 157 }; 158 159 template<class T> 160 class RValue 161 { 162 public: 163 explicit RValue(Value *rvalue); 164 165 RValue(const T &lvalue); 166 RValue(typename IntLiteral<T>::type i); 167 RValue(typename FloatLiteral<T>::type f); 168 RValue(const Reference<T> &rhs); 169 170 RValue<T> &operator=(const RValue<T>&) = delete; 171 172 Value *value; // FIXME: Make private 173 }; 174 175 template<typename T> 176 struct Argument 177 { 178 explicit Argument(Value *value) : value(value) {} 179 180 Value *value; 181 }; 182 183 class Bool : public LValue<Bool> 184 { 185 public: 186 Bool(Argument<Bool> argument); 187 188 Bool() = default; 189 Bool(bool x); 190 Bool(RValue<Bool> rhs); 191 Bool(const Bool &rhs); 192 Bool(const Reference<Bool> &rhs); 193 194 // RValue<Bool> operator=(bool rhs); // FIXME: Implement 195 RValue<Bool> operator=(RValue<Bool> rhs); 196 RValue<Bool> operator=(const Bool &rhs); 197 RValue<Bool> operator=(const Reference<Bool> &rhs); 198 199 static Type *getType(); 200 }; 201 202 RValue<Bool> operator!(RValue<Bool> val); 203 RValue<Bool> operator&&(RValue<Bool> lhs, RValue<Bool> rhs); 204 RValue<Bool> operator||(RValue<Bool> lhs, RValue<Bool> rhs); 205 206 class Byte : public LValue<Byte> 207 { 208 public: 209 Byte(Argument<Byte> argument); 210 211 explicit Byte(RValue<Int> cast); 212 explicit Byte(RValue<UInt> cast); 213 explicit Byte(RValue<UShort> cast); 214 215 Byte() = default; 216 Byte(int x); 217 Byte(unsigned char x); 218 Byte(RValue<Byte> rhs); 219 Byte(const Byte &rhs); 220 Byte(const Reference<Byte> &rhs); 221 222 // RValue<Byte> operator=(unsigned char rhs); // FIXME: Implement 223 RValue<Byte> operator=(RValue<Byte> rhs); 224 RValue<Byte> operator=(const Byte &rhs); 225 RValue<Byte> operator=(const Reference<Byte> &rhs); 226 227 static Type *getType(); 228 }; 229 230 RValue<Byte> operator+(RValue<Byte> lhs, RValue<Byte> rhs); 231 RValue<Byte> operator-(RValue<Byte> lhs, RValue<Byte> rhs); 232 RValue<Byte> operator*(RValue<Byte> lhs, RValue<Byte> rhs); 233 RValue<Byte> operator/(RValue<Byte> lhs, RValue<Byte> rhs); 234 RValue<Byte> operator%(RValue<Byte> lhs, RValue<Byte> rhs); 235 RValue<Byte> operator&(RValue<Byte> lhs, RValue<Byte> rhs); 236 RValue<Byte> operator|(RValue<Byte> lhs, RValue<Byte> rhs); 237 RValue<Byte> operator^(RValue<Byte> lhs, RValue<Byte> rhs); 238 RValue<Byte> operator<<(RValue<Byte> lhs, RValue<Byte> rhs); 239 RValue<Byte> operator>>(RValue<Byte> lhs, RValue<Byte> rhs); 240 RValue<Byte> operator+=(Byte &lhs, RValue<Byte> rhs); 241 RValue<Byte> operator-=(Byte &lhs, RValue<Byte> rhs); 242 RValue<Byte> operator*=(Byte &lhs, RValue<Byte> rhs); 243 RValue<Byte> operator/=(Byte &lhs, RValue<Byte> rhs); 244 RValue<Byte> operator%=(Byte &lhs, RValue<Byte> rhs); 245 RValue<Byte> operator&=(Byte &lhs, RValue<Byte> rhs); 246 RValue<Byte> operator|=(Byte &lhs, RValue<Byte> rhs); 247 RValue<Byte> operator^=(Byte &lhs, RValue<Byte> rhs); 248 RValue<Byte> operator<<=(Byte &lhs, RValue<Byte> rhs); 249 RValue<Byte> operator>>=(Byte &lhs, RValue<Byte> rhs); 250 RValue<Byte> operator+(RValue<Byte> val); 251 RValue<Byte> operator-(RValue<Byte> val); 252 RValue<Byte> operator~(RValue<Byte> val); 253 RValue<Byte> operator++(Byte &val, int); // Post-increment 254 const Byte &operator++(Byte &val); // Pre-increment 255 RValue<Byte> operator--(Byte &val, int); // Post-decrement 256 const Byte &operator--(Byte &val); // Pre-decrement 257 RValue<Bool> operator<(RValue<Byte> lhs, RValue<Byte> rhs); 258 RValue<Bool> operator<=(RValue<Byte> lhs, RValue<Byte> rhs); 259 RValue<Bool> operator>(RValue<Byte> lhs, RValue<Byte> rhs); 260 RValue<Bool> operator>=(RValue<Byte> lhs, RValue<Byte> rhs); 261 RValue<Bool> operator!=(RValue<Byte> lhs, RValue<Byte> rhs); 262 RValue<Bool> operator==(RValue<Byte> lhs, RValue<Byte> rhs); 263 264 class SByte : public LValue<SByte> 265 { 266 public: 267 SByte(Argument<SByte> argument); 268 269 explicit SByte(RValue<Int> cast); 270 explicit SByte(RValue<Short> cast); 271 272 SByte() = default; 273 SByte(signed char x); 274 SByte(RValue<SByte> rhs); 275 SByte(const SByte &rhs); 276 SByte(const Reference<SByte> &rhs); 277 278 // RValue<SByte> operator=(signed char rhs); // FIXME: Implement 279 RValue<SByte> operator=(RValue<SByte> rhs); 280 RValue<SByte> operator=(const SByte &rhs); 281 RValue<SByte> operator=(const Reference<SByte> &rhs); 282 283 static Type *getType(); 284 }; 285 286 RValue<SByte> operator+(RValue<SByte> lhs, RValue<SByte> rhs); 287 RValue<SByte> operator-(RValue<SByte> lhs, RValue<SByte> rhs); 288 RValue<SByte> operator*(RValue<SByte> lhs, RValue<SByte> rhs); 289 RValue<SByte> operator/(RValue<SByte> lhs, RValue<SByte> rhs); 290 RValue<SByte> operator%(RValue<SByte> lhs, RValue<SByte> rhs); 291 RValue<SByte> operator&(RValue<SByte> lhs, RValue<SByte> rhs); 292 RValue<SByte> operator|(RValue<SByte> lhs, RValue<SByte> rhs); 293 RValue<SByte> operator^(RValue<SByte> lhs, RValue<SByte> rhs); 294 RValue<SByte> operator<<(RValue<SByte> lhs, RValue<SByte> rhs); 295 RValue<SByte> operator>>(RValue<SByte> lhs, RValue<SByte> rhs); 296 RValue<SByte> operator+=(SByte &lhs, RValue<SByte> rhs); 297 RValue<SByte> operator-=(SByte &lhs, RValue<SByte> rhs); 298 RValue<SByte> operator*=(SByte &lhs, RValue<SByte> rhs); 299 RValue<SByte> operator/=(SByte &lhs, RValue<SByte> rhs); 300 RValue<SByte> operator%=(SByte &lhs, RValue<SByte> rhs); 301 RValue<SByte> operator&=(SByte &lhs, RValue<SByte> rhs); 302 RValue<SByte> operator|=(SByte &lhs, RValue<SByte> rhs); 303 RValue<SByte> operator^=(SByte &lhs, RValue<SByte> rhs); 304 RValue<SByte> operator<<=(SByte &lhs, RValue<SByte> rhs); 305 RValue<SByte> operator>>=(SByte &lhs, RValue<SByte> rhs); 306 RValue<SByte> operator+(RValue<SByte> val); 307 RValue<SByte> operator-(RValue<SByte> val); 308 RValue<SByte> operator~(RValue<SByte> val); 309 RValue<SByte> operator++(SByte &val, int); // Post-increment 310 const SByte &operator++(SByte &val); // Pre-increment 311 RValue<SByte> operator--(SByte &val, int); // Post-decrement 312 const SByte &operator--(SByte &val); // Pre-decrement 313 RValue<Bool> operator<(RValue<SByte> lhs, RValue<SByte> rhs); 314 RValue<Bool> operator<=(RValue<SByte> lhs, RValue<SByte> rhs); 315 RValue<Bool> operator>(RValue<SByte> lhs, RValue<SByte> rhs); 316 RValue<Bool> operator>=(RValue<SByte> lhs, RValue<SByte> rhs); 317 RValue<Bool> operator!=(RValue<SByte> lhs, RValue<SByte> rhs); 318 RValue<Bool> operator==(RValue<SByte> lhs, RValue<SByte> rhs); 319 320 class Short : public LValue<Short> 321 { 322 public: 323 Short(Argument<Short> argument); 324 325 explicit Short(RValue<Int> cast); 326 327 Short() = default; 328 Short(short x); 329 Short(RValue<Short> rhs); 330 Short(const Short &rhs); 331 Short(const Reference<Short> &rhs); 332 333 // RValue<Short> operator=(short rhs); // FIXME: Implement 334 RValue<Short> operator=(RValue<Short> rhs); 335 RValue<Short> operator=(const Short &rhs); 336 RValue<Short> operator=(const Reference<Short> &rhs); 337 338 static Type *getType(); 339 }; 340 341 RValue<Short> operator+(RValue<Short> lhs, RValue<Short> rhs); 342 RValue<Short> operator-(RValue<Short> lhs, RValue<Short> rhs); 343 RValue<Short> operator*(RValue<Short> lhs, RValue<Short> rhs); 344 RValue<Short> operator/(RValue<Short> lhs, RValue<Short> rhs); 345 RValue<Short> operator%(RValue<Short> lhs, RValue<Short> rhs); 346 RValue<Short> operator&(RValue<Short> lhs, RValue<Short> rhs); 347 RValue<Short> operator|(RValue<Short> lhs, RValue<Short> rhs); 348 RValue<Short> operator^(RValue<Short> lhs, RValue<Short> rhs); 349 RValue<Short> operator<<(RValue<Short> lhs, RValue<Short> rhs); 350 RValue<Short> operator>>(RValue<Short> lhs, RValue<Short> rhs); 351 RValue<Short> operator+=(Short &lhs, RValue<Short> rhs); 352 RValue<Short> operator-=(Short &lhs, RValue<Short> rhs); 353 RValue<Short> operator*=(Short &lhs, RValue<Short> rhs); 354 RValue<Short> operator/=(Short &lhs, RValue<Short> rhs); 355 RValue<Short> operator%=(Short &lhs, RValue<Short> rhs); 356 RValue<Short> operator&=(Short &lhs, RValue<Short> rhs); 357 RValue<Short> operator|=(Short &lhs, RValue<Short> rhs); 358 RValue<Short> operator^=(Short &lhs, RValue<Short> rhs); 359 RValue<Short> operator<<=(Short &lhs, RValue<Short> rhs); 360 RValue<Short> operator>>=(Short &lhs, RValue<Short> rhs); 361 RValue<Short> operator+(RValue<Short> val); 362 RValue<Short> operator-(RValue<Short> val); 363 RValue<Short> operator~(RValue<Short> val); 364 RValue<Short> operator++(Short &val, int); // Post-increment 365 const Short &operator++(Short &val); // Pre-increment 366 RValue<Short> operator--(Short &val, int); // Post-decrement 367 const Short &operator--(Short &val); // Pre-decrement 368 RValue<Bool> operator<(RValue<Short> lhs, RValue<Short> rhs); 369 RValue<Bool> operator<=(RValue<Short> lhs, RValue<Short> rhs); 370 RValue<Bool> operator>(RValue<Short> lhs, RValue<Short> rhs); 371 RValue<Bool> operator>=(RValue<Short> lhs, RValue<Short> rhs); 372 RValue<Bool> operator!=(RValue<Short> lhs, RValue<Short> rhs); 373 RValue<Bool> operator==(RValue<Short> lhs, RValue<Short> rhs); 374 375 class UShort : public LValue<UShort> 376 { 377 public: 378 UShort(Argument<UShort> argument); 379 380 explicit UShort(RValue<UInt> cast); 381 explicit UShort(RValue<Int> cast); 382 383 UShort() = default; 384 UShort(unsigned short x); 385 UShort(RValue<UShort> rhs); 386 UShort(const UShort &rhs); 387 UShort(const Reference<UShort> &rhs); 388 389 // RValue<UShort> operator=(unsigned short rhs); // FIXME: Implement 390 RValue<UShort> operator=(RValue<UShort> rhs); 391 RValue<UShort> operator=(const UShort &rhs); 392 RValue<UShort> operator=(const Reference<UShort> &rhs); 393 394 static Type *getType(); 395 }; 396 397 RValue<UShort> operator+(RValue<UShort> lhs, RValue<UShort> rhs); 398 RValue<UShort> operator-(RValue<UShort> lhs, RValue<UShort> rhs); 399 RValue<UShort> operator*(RValue<UShort> lhs, RValue<UShort> rhs); 400 RValue<UShort> operator/(RValue<UShort> lhs, RValue<UShort> rhs); 401 RValue<UShort> operator%(RValue<UShort> lhs, RValue<UShort> rhs); 402 RValue<UShort> operator&(RValue<UShort> lhs, RValue<UShort> rhs); 403 RValue<UShort> operator|(RValue<UShort> lhs, RValue<UShort> rhs); 404 RValue<UShort> operator^(RValue<UShort> lhs, RValue<UShort> rhs); 405 RValue<UShort> operator<<(RValue<UShort> lhs, RValue<UShort> rhs); 406 RValue<UShort> operator>>(RValue<UShort> lhs, RValue<UShort> rhs); 407 RValue<UShort> operator+=(UShort &lhs, RValue<UShort> rhs); 408 RValue<UShort> operator-=(UShort &lhs, RValue<UShort> rhs); 409 RValue<UShort> operator*=(UShort &lhs, RValue<UShort> rhs); 410 RValue<UShort> operator/=(UShort &lhs, RValue<UShort> rhs); 411 RValue<UShort> operator%=(UShort &lhs, RValue<UShort> rhs); 412 RValue<UShort> operator&=(UShort &lhs, RValue<UShort> rhs); 413 RValue<UShort> operator|=(UShort &lhs, RValue<UShort> rhs); 414 RValue<UShort> operator^=(UShort &lhs, RValue<UShort> rhs); 415 RValue<UShort> operator<<=(UShort &lhs, RValue<UShort> rhs); 416 RValue<UShort> operator>>=(UShort &lhs, RValue<UShort> rhs); 417 RValue<UShort> operator+(RValue<UShort> val); 418 RValue<UShort> operator-(RValue<UShort> val); 419 RValue<UShort> operator~(RValue<UShort> val); 420 RValue<UShort> operator++(UShort &val, int); // Post-increment 421 const UShort &operator++(UShort &val); // Pre-increment 422 RValue<UShort> operator--(UShort &val, int); // Post-decrement 423 const UShort &operator--(UShort &val); // Pre-decrement 424 RValue<Bool> operator<(RValue<UShort> lhs, RValue<UShort> rhs); 425 RValue<Bool> operator<=(RValue<UShort> lhs, RValue<UShort> rhs); 426 RValue<Bool> operator>(RValue<UShort> lhs, RValue<UShort> rhs); 427 RValue<Bool> operator>=(RValue<UShort> lhs, RValue<UShort> rhs); 428 RValue<Bool> operator!=(RValue<UShort> lhs, RValue<UShort> rhs); 429 RValue<Bool> operator==(RValue<UShort> lhs, RValue<UShort> rhs); 430 431 class Byte4 : public LValue<Byte4> 432 { 433 public: 434 explicit Byte4(RValue<Byte8> cast); 435 436 Byte4() = default; 437 // Byte4(int x, int y, int z, int w); 438 // Byte4(RValue<Byte4> rhs); 439 // Byte4(const Byte4 &rhs); 440 Byte4(const Reference<Byte4> &rhs); 441 442 // RValue<Byte4> operator=(RValue<Byte4> rhs); 443 // RValue<Byte4> operator=(const Byte4 &rhs); 444 // RValue<Byte4> operator=(const Reference<Byte4> &rhs); 445 446 static Type *getType(); 447 }; 448 449 // RValue<Byte4> operator+(RValue<Byte4> lhs, RValue<Byte4> rhs); 450 // RValue<Byte4> operator-(RValue<Byte4> lhs, RValue<Byte4> rhs); 451 // RValue<Byte4> operator*(RValue<Byte4> lhs, RValue<Byte4> rhs); 452 // RValue<Byte4> operator/(RValue<Byte4> lhs, RValue<Byte4> rhs); 453 // RValue<Byte4> operator%(RValue<Byte4> lhs, RValue<Byte4> rhs); 454 // RValue<Byte4> operator&(RValue<Byte4> lhs, RValue<Byte4> rhs); 455 // RValue<Byte4> operator|(RValue<Byte4> lhs, RValue<Byte4> rhs); 456 // RValue<Byte4> operator^(RValue<Byte4> lhs, RValue<Byte4> rhs); 457 // RValue<Byte4> operator<<(RValue<Byte4> lhs, RValue<Byte4> rhs); 458 // RValue<Byte4> operator>>(RValue<Byte4> lhs, RValue<Byte4> rhs); 459 // RValue<Byte4> operator+=(Byte4 &lhs, RValue<Byte4> rhs); 460 // RValue<Byte4> operator-=(Byte4 &lhs, RValue<Byte4> rhs); 461 // RValue<Byte4> operator*=(Byte4 &lhs, RValue<Byte4> rhs); 462 // RValue<Byte4> operator/=(Byte4 &lhs, RValue<Byte4> rhs); 463 // RValue<Byte4> operator%=(Byte4 &lhs, RValue<Byte4> rhs); 464 // RValue<Byte4> operator&=(Byte4 &lhs, RValue<Byte4> rhs); 465 // RValue<Byte4> operator|=(Byte4 &lhs, RValue<Byte4> rhs); 466 // RValue<Byte4> operator^=(Byte4 &lhs, RValue<Byte4> rhs); 467 // RValue<Byte4> operator<<=(Byte4 &lhs, RValue<Byte4> rhs); 468 // RValue<Byte4> operator>>=(Byte4 &lhs, RValue<Byte4> rhs); 469 // RValue<Byte4> operator+(RValue<Byte4> val); 470 // RValue<Byte4> operator-(RValue<Byte4> val); 471 // RValue<Byte4> operator~(RValue<Byte4> val); 472 // RValue<Byte4> operator++(Byte4 &val, int); // Post-increment 473 // const Byte4 &operator++(Byte4 &val); // Pre-increment 474 // RValue<Byte4> operator--(Byte4 &val, int); // Post-decrement 475 // const Byte4 &operator--(Byte4 &val); // Pre-decrement 476 477 class SByte4 : public LValue<SByte4> 478 { 479 public: 480 SByte4() = default; 481 // SByte4(int x, int y, int z, int w); 482 // SByte4(RValue<SByte4> rhs); 483 // SByte4(const SByte4 &rhs); 484 // SByte4(const Reference<SByte4> &rhs); 485 486 // RValue<SByte4> operator=(RValue<SByte4> rhs); 487 // RValue<SByte4> operator=(const SByte4 &rhs); 488 // RValue<SByte4> operator=(const Reference<SByte4> &rhs); 489 490 static Type *getType(); 491 }; 492 493 // RValue<SByte4> operator+(RValue<SByte4> lhs, RValue<SByte4> rhs); 494 // RValue<SByte4> operator-(RValue<SByte4> lhs, RValue<SByte4> rhs); 495 // RValue<SByte4> operator*(RValue<SByte4> lhs, RValue<SByte4> rhs); 496 // RValue<SByte4> operator/(RValue<SByte4> lhs, RValue<SByte4> rhs); 497 // RValue<SByte4> operator%(RValue<SByte4> lhs, RValue<SByte4> rhs); 498 // RValue<SByte4> operator&(RValue<SByte4> lhs, RValue<SByte4> rhs); 499 // RValue<SByte4> operator|(RValue<SByte4> lhs, RValue<SByte4> rhs); 500 // RValue<SByte4> operator^(RValue<SByte4> lhs, RValue<SByte4> rhs); 501 // RValue<SByte4> operator<<(RValue<SByte4> lhs, RValue<SByte4> rhs); 502 // RValue<SByte4> operator>>(RValue<SByte4> lhs, RValue<SByte4> rhs); 503 // RValue<SByte4> operator+=(SByte4 &lhs, RValue<SByte4> rhs); 504 // RValue<SByte4> operator-=(SByte4 &lhs, RValue<SByte4> rhs); 505 // RValue<SByte4> operator*=(SByte4 &lhs, RValue<SByte4> rhs); 506 // RValue<SByte4> operator/=(SByte4 &lhs, RValue<SByte4> rhs); 507 // RValue<SByte4> operator%=(SByte4 &lhs, RValue<SByte4> rhs); 508 // RValue<SByte4> operator&=(SByte4 &lhs, RValue<SByte4> rhs); 509 // RValue<SByte4> operator|=(SByte4 &lhs, RValue<SByte4> rhs); 510 // RValue<SByte4> operator^=(SByte4 &lhs, RValue<SByte4> rhs); 511 // RValue<SByte4> operator<<=(SByte4 &lhs, RValue<SByte4> rhs); 512 // RValue<SByte4> operator>>=(SByte4 &lhs, RValue<SByte4> rhs); 513 // RValue<SByte4> operator+(RValue<SByte4> val); 514 // RValue<SByte4> operator-(RValue<SByte4> val); 515 // RValue<SByte4> operator~(RValue<SByte4> val); 516 // RValue<SByte4> operator++(SByte4 &val, int); // Post-increment 517 // const SByte4 &operator++(SByte4 &val); // Pre-increment 518 // RValue<SByte4> operator--(SByte4 &val, int); // Post-decrement 519 // const SByte4 &operator--(SByte4 &val); // Pre-decrement 520 521 class Byte8 : public LValue<Byte8> 522 { 523 public: 524 Byte8() = default; 525 Byte8(uint8_t x0, uint8_t x1, uint8_t x2, uint8_t x3, uint8_t x4, uint8_t x5, uint8_t x6, uint8_t x7); 526 Byte8(RValue<Byte8> rhs); 527 Byte8(const Byte8 &rhs); 528 Byte8(const Reference<Byte8> &rhs); 529 530 RValue<Byte8> operator=(RValue<Byte8> rhs); 531 RValue<Byte8> operator=(const Byte8 &rhs); 532 RValue<Byte8> operator=(const Reference<Byte8> &rhs); 533 534 static Type *getType(); 535 }; 536 537 RValue<Byte8> operator+(RValue<Byte8> lhs, RValue<Byte8> rhs); 538 RValue<Byte8> operator-(RValue<Byte8> lhs, RValue<Byte8> rhs); 539 // RValue<Byte8> operator*(RValue<Byte8> lhs, RValue<Byte8> rhs); 540 // RValue<Byte8> operator/(RValue<Byte8> lhs, RValue<Byte8> rhs); 541 // RValue<Byte8> operator%(RValue<Byte8> lhs, RValue<Byte8> rhs); 542 RValue<Byte8> operator&(RValue<Byte8> lhs, RValue<Byte8> rhs); 543 RValue<Byte8> operator|(RValue<Byte8> lhs, RValue<Byte8> rhs); 544 RValue<Byte8> operator^(RValue<Byte8> lhs, RValue<Byte8> rhs); 545 // RValue<Byte8> operator<<(RValue<Byte8> lhs, RValue<Byte8> rhs); 546 // RValue<Byte8> operator>>(RValue<Byte8> lhs, RValue<Byte8> rhs); 547 RValue<Byte8> operator+=(Byte8 &lhs, RValue<Byte8> rhs); 548 RValue<Byte8> operator-=(Byte8 &lhs, RValue<Byte8> rhs); 549 // RValue<Byte8> operator*=(Byte8 &lhs, RValue<Byte8> rhs); 550 // RValue<Byte8> operator/=(Byte8 &lhs, RValue<Byte8> rhs); 551 // RValue<Byte8> operator%=(Byte8 &lhs, RValue<Byte8> rhs); 552 RValue<Byte8> operator&=(Byte8 &lhs, RValue<Byte8> rhs); 553 RValue<Byte8> operator|=(Byte8 &lhs, RValue<Byte8> rhs); 554 RValue<Byte8> operator^=(Byte8 &lhs, RValue<Byte8> rhs); 555 // RValue<Byte8> operator<<=(Byte8 &lhs, RValue<Byte8> rhs); 556 // RValue<Byte8> operator>>=(Byte8 &lhs, RValue<Byte8> rhs); 557 // RValue<Byte8> operator+(RValue<Byte8> val); 558 // RValue<Byte8> operator-(RValue<Byte8> val); 559 RValue<Byte8> operator~(RValue<Byte8> val); 560 // RValue<Byte8> operator++(Byte8 &val, int); // Post-increment 561 // const Byte8 &operator++(Byte8 &val); // Pre-increment 562 // RValue<Byte8> operator--(Byte8 &val, int); // Post-decrement 563 // const Byte8 &operator--(Byte8 &val); // Pre-decrement 564 565 RValue<Byte8> AddSat(RValue<Byte8> x, RValue<Byte8> y); 566 RValue<Byte8> SubSat(RValue<Byte8> x, RValue<Byte8> y); 567 RValue<Short4> Unpack(RValue<Byte4> x); 568 RValue<Short4> Unpack(RValue<Byte4> x, RValue<Byte4> y); 569 RValue<Short4> UnpackLow(RValue<Byte8> x, RValue<Byte8> y); 570 RValue<Short4> UnpackHigh(RValue<Byte8> x, RValue<Byte8> y); 571 RValue<Int> SignMask(RValue<Byte8> x); 572 // RValue<Byte8> CmpGT(RValue<Byte8> x, RValue<Byte8> y); 573 RValue<Byte8> CmpEQ(RValue<Byte8> x, RValue<Byte8> y); 574 575 class SByte8 : public LValue<SByte8> 576 { 577 public: 578 SByte8() = default; 579 SByte8(uint8_t x0, uint8_t x1, uint8_t x2, uint8_t x3, uint8_t x4, uint8_t x5, uint8_t x6, uint8_t x7); 580 SByte8(RValue<SByte8> rhs); 581 SByte8(const SByte8 &rhs); 582 SByte8(const Reference<SByte8> &rhs); 583 584 RValue<SByte8> operator=(RValue<SByte8> rhs); 585 RValue<SByte8> operator=(const SByte8 &rhs); 586 RValue<SByte8> operator=(const Reference<SByte8> &rhs); 587 588 static Type *getType(); 589 }; 590 591 RValue<SByte8> operator+(RValue<SByte8> lhs, RValue<SByte8> rhs); 592 RValue<SByte8> operator-(RValue<SByte8> lhs, RValue<SByte8> rhs); 593 // RValue<SByte8> operator*(RValue<SByte8> lhs, RValue<SByte8> rhs); 594 // RValue<SByte8> operator/(RValue<SByte8> lhs, RValue<SByte8> rhs); 595 // RValue<SByte8> operator%(RValue<SByte8> lhs, RValue<SByte8> rhs); 596 RValue<SByte8> operator&(RValue<SByte8> lhs, RValue<SByte8> rhs); 597 RValue<SByte8> operator|(RValue<SByte8> lhs, RValue<SByte8> rhs); 598 RValue<SByte8> operator^(RValue<SByte8> lhs, RValue<SByte8> rhs); 599 // RValue<SByte8> operator<<(RValue<SByte8> lhs, RValue<SByte8> rhs); 600 // RValue<SByte8> operator>>(RValue<SByte8> lhs, RValue<SByte8> rhs); 601 RValue<SByte8> operator+=(SByte8 &lhs, RValue<SByte8> rhs); 602 RValue<SByte8> operator-=(SByte8 &lhs, RValue<SByte8> rhs); 603 // RValue<SByte8> operator*=(SByte8 &lhs, RValue<SByte8> rhs); 604 // RValue<SByte8> operator/=(SByte8 &lhs, RValue<SByte8> rhs); 605 // RValue<SByte8> operator%=(SByte8 &lhs, RValue<SByte8> rhs); 606 RValue<SByte8> operator&=(SByte8 &lhs, RValue<SByte8> rhs); 607 RValue<SByte8> operator|=(SByte8 &lhs, RValue<SByte8> rhs); 608 RValue<SByte8> operator^=(SByte8 &lhs, RValue<SByte8> rhs); 609 // RValue<SByte8> operator<<=(SByte8 &lhs, RValue<SByte8> rhs); 610 // RValue<SByte8> operator>>=(SByte8 &lhs, RValue<SByte8> rhs); 611 // RValue<SByte8> operator+(RValue<SByte8> val); 612 // RValue<SByte8> operator-(RValue<SByte8> val); 613 RValue<SByte8> operator~(RValue<SByte8> val); 614 // RValue<SByte8> operator++(SByte8 &val, int); // Post-increment 615 // const SByte8 &operator++(SByte8 &val); // Pre-increment 616 // RValue<SByte8> operator--(SByte8 &val, int); // Post-decrement 617 // const SByte8 &operator--(SByte8 &val); // Pre-decrement 618 619 RValue<SByte8> AddSat(RValue<SByte8> x, RValue<SByte8> y); 620 RValue<SByte8> SubSat(RValue<SByte8> x, RValue<SByte8> y); 621 RValue<Short4> UnpackLow(RValue<SByte8> x, RValue<SByte8> y); 622 RValue<Short4> UnpackHigh(RValue<SByte8> x, RValue<SByte8> y); 623 RValue<Int> SignMask(RValue<SByte8> x); 624 RValue<Byte8> CmpGT(RValue<SByte8> x, RValue<SByte8> y); 625 RValue<Byte8> CmpEQ(RValue<SByte8> x, RValue<SByte8> y); 626 627 class Byte16 : public LValue<Byte16> 628 { 629 public: 630 Byte16() = default; 631 // Byte16(int x, int y, int z, int w); 632 Byte16(RValue<Byte16> rhs); 633 Byte16(const Byte16 &rhs); 634 Byte16(const Reference<Byte16> &rhs); 635 636 RValue<Byte16> operator=(RValue<Byte16> rhs); 637 RValue<Byte16> operator=(const Byte16 &rhs); 638 RValue<Byte16> operator=(const Reference<Byte16> &rhs); 639 640 static Type *getType(); 641 }; 642 643 // RValue<Byte16> operator+(RValue<Byte16> lhs, RValue<Byte16> rhs); 644 // RValue<Byte16> operator-(RValue<Byte16> lhs, RValue<Byte16> rhs); 645 // RValue<Byte16> operator*(RValue<Byte16> lhs, RValue<Byte16> rhs); 646 // RValue<Byte16> operator/(RValue<Byte16> lhs, RValue<Byte16> rhs); 647 // RValue<Byte16> operator%(RValue<Byte16> lhs, RValue<Byte16> rhs); 648 // RValue<Byte16> operator&(RValue<Byte16> lhs, RValue<Byte16> rhs); 649 // RValue<Byte16> operator|(RValue<Byte16> lhs, RValue<Byte16> rhs); 650 // RValue<Byte16> operator^(RValue<Byte16> lhs, RValue<Byte16> rhs); 651 // RValue<Byte16> operator<<(RValue<Byte16> lhs, RValue<Byte16> rhs); 652 // RValue<Byte16> operator>>(RValue<Byte16> lhs, RValue<Byte16> rhs); 653 // RValue<Byte16> operator+=(Byte16 &lhs, RValue<Byte16> rhs); 654 // RValue<Byte16> operator-=(Byte16 &lhs, RValue<Byte16> rhs); 655 // RValue<Byte16> operator*=(Byte16 &lhs, RValue<Byte16> rhs); 656 // RValue<Byte16> operator/=(Byte16 &lhs, RValue<Byte16> rhs); 657 // RValue<Byte16> operator%=(Byte16 &lhs, RValue<Byte16> rhs); 658 // RValue<Byte16> operator&=(Byte16 &lhs, RValue<Byte16> rhs); 659 // RValue<Byte16> operator|=(Byte16 &lhs, RValue<Byte16> rhs); 660 // RValue<Byte16> operator^=(Byte16 &lhs, RValue<Byte16> rhs); 661 // RValue<Byte16> operator<<=(Byte16 &lhs, RValue<Byte16> rhs); 662 // RValue<Byte16> operator>>=(Byte16 &lhs, RValue<Byte16> rhs); 663 // RValue<Byte16> operator+(RValue<Byte16> val); 664 // RValue<Byte16> operator-(RValue<Byte16> val); 665 // RValue<Byte16> operator~(RValue<Byte16> val); 666 // RValue<Byte16> operator++(Byte16 &val, int); // Post-increment 667 // const Byte16 &operator++(Byte16 &val); // Pre-increment 668 // RValue<Byte16> operator--(Byte16 &val, int); // Post-decrement 669 // const Byte16 &operator--(Byte16 &val); // Pre-decrement 670 671 class SByte16 : public LValue<SByte16> 672 { 673 public: 674 SByte16() = default; 675 // SByte16(int x, int y, int z, int w); 676 // SByte16(RValue<SByte16> rhs); 677 // SByte16(const SByte16 &rhs); 678 // SByte16(const Reference<SByte16> &rhs); 679 680 // RValue<SByte16> operator=(RValue<SByte16> rhs); 681 // RValue<SByte16> operator=(const SByte16 &rhs); 682 // RValue<SByte16> operator=(const Reference<SByte16> &rhs); 683 684 static Type *getType(); 685 }; 686 687 // RValue<SByte16> operator+(RValue<SByte16> lhs, RValue<SByte16> rhs); 688 // RValue<SByte16> operator-(RValue<SByte16> lhs, RValue<SByte16> rhs); 689 // RValue<SByte16> operator*(RValue<SByte16> lhs, RValue<SByte16> rhs); 690 // RValue<SByte16> operator/(RValue<SByte16> lhs, RValue<SByte16> rhs); 691 // RValue<SByte16> operator%(RValue<SByte16> lhs, RValue<SByte16> rhs); 692 // RValue<SByte16> operator&(RValue<SByte16> lhs, RValue<SByte16> rhs); 693 // RValue<SByte16> operator|(RValue<SByte16> lhs, RValue<SByte16> rhs); 694 // RValue<SByte16> operator^(RValue<SByte16> lhs, RValue<SByte16> rhs); 695 // RValue<SByte16> operator<<(RValue<SByte16> lhs, RValue<SByte16> rhs); 696 // RValue<SByte16> operator>>(RValue<SByte16> lhs, RValue<SByte16> rhs); 697 // RValue<SByte16> operator+=(SByte16 &lhs, RValue<SByte16> rhs); 698 // RValue<SByte16> operator-=(SByte16 &lhs, RValue<SByte16> rhs); 699 // RValue<SByte16> operator*=(SByte16 &lhs, RValue<SByte16> rhs); 700 // RValue<SByte16> operator/=(SByte16 &lhs, RValue<SByte16> rhs); 701 // RValue<SByte16> operator%=(SByte16 &lhs, RValue<SByte16> rhs); 702 // RValue<SByte16> operator&=(SByte16 &lhs, RValue<SByte16> rhs); 703 // RValue<SByte16> operator|=(SByte16 &lhs, RValue<SByte16> rhs); 704 // RValue<SByte16> operator^=(SByte16 &lhs, RValue<SByte16> rhs); 705 // RValue<SByte16> operator<<=(SByte16 &lhs, RValue<SByte16> rhs); 706 // RValue<SByte16> operator>>=(SByte16 &lhs, RValue<SByte16> rhs); 707 // RValue<SByte16> operator+(RValue<SByte16> val); 708 // RValue<SByte16> operator-(RValue<SByte16> val); 709 // RValue<SByte16> operator~(RValue<SByte16> val); 710 // RValue<SByte16> operator++(SByte16 &val, int); // Post-increment 711 // const SByte16 &operator++(SByte16 &val); // Pre-increment 712 // RValue<SByte16> operator--(SByte16 &val, int); // Post-decrement 713 // const SByte16 &operator--(SByte16 &val); // Pre-decrement 714 715 class Short2 : public LValue<Short2> 716 { 717 public: 718 explicit Short2(RValue<Short4> cast); 719 720 static Type *getType(); 721 }; 722 723 class UShort2 : public LValue<UShort2> 724 { 725 public: 726 explicit UShort2(RValue<UShort4> cast); 727 728 static Type *getType(); 729 }; 730 731 class Short4 : public LValue<Short4> 732 { 733 public: 734 explicit Short4(RValue<Int> cast); 735 explicit Short4(RValue<Int4> cast); 736 // explicit Short4(RValue<Float> cast); 737 explicit Short4(RValue<Float4> cast); 738 739 Short4() = default; 740 Short4(short xyzw); 741 Short4(short x, short y, short z, short w); 742 Short4(RValue<Short4> rhs); 743 Short4(const Short4 &rhs); 744 Short4(const Reference<Short4> &rhs); 745 Short4(RValue<UShort4> rhs); 746 Short4(const UShort4 &rhs); 747 Short4(const Reference<UShort4> &rhs); 748 749 RValue<Short4> operator=(RValue<Short4> rhs); 750 RValue<Short4> operator=(const Short4 &rhs); 751 RValue<Short4> operator=(const Reference<Short4> &rhs); 752 RValue<Short4> operator=(RValue<UShort4> rhs); 753 RValue<Short4> operator=(const UShort4 &rhs); 754 RValue<Short4> operator=(const Reference<UShort4> &rhs); 755 756 static Type *getType(); 757 }; 758 759 RValue<Short4> operator+(RValue<Short4> lhs, RValue<Short4> rhs); 760 RValue<Short4> operator-(RValue<Short4> lhs, RValue<Short4> rhs); 761 RValue<Short4> operator*(RValue<Short4> lhs, RValue<Short4> rhs); 762 // RValue<Short4> operator/(RValue<Short4> lhs, RValue<Short4> rhs); 763 // RValue<Short4> operator%(RValue<Short4> lhs, RValue<Short4> rhs); 764 RValue<Short4> operator&(RValue<Short4> lhs, RValue<Short4> rhs); 765 RValue<Short4> operator|(RValue<Short4> lhs, RValue<Short4> rhs); 766 RValue<Short4> operator^(RValue<Short4> lhs, RValue<Short4> rhs); 767 RValue<Short4> operator<<(RValue<Short4> lhs, unsigned char rhs); 768 RValue<Short4> operator>>(RValue<Short4> lhs, unsigned char rhs); 769 RValue<Short4> operator+=(Short4 &lhs, RValue<Short4> rhs); 770 RValue<Short4> operator-=(Short4 &lhs, RValue<Short4> rhs); 771 RValue<Short4> operator*=(Short4 &lhs, RValue<Short4> rhs); 772 // RValue<Short4> operator/=(Short4 &lhs, RValue<Short4> rhs); 773 // RValue<Short4> operator%=(Short4 &lhs, RValue<Short4> rhs); 774 RValue<Short4> operator&=(Short4 &lhs, RValue<Short4> rhs); 775 RValue<Short4> operator|=(Short4 &lhs, RValue<Short4> rhs); 776 RValue<Short4> operator^=(Short4 &lhs, RValue<Short4> rhs); 777 RValue<Short4> operator<<=(Short4 &lhs, unsigned char rhs); 778 RValue<Short4> operator>>=(Short4 &lhs, unsigned char rhs); 779 // RValue<Short4> operator+(RValue<Short4> val); 780 RValue<Short4> operator-(RValue<Short4> val); 781 RValue<Short4> operator~(RValue<Short4> val); 782 // RValue<Short4> operator++(Short4 &val, int); // Post-increment 783 // const Short4 &operator++(Short4 &val); // Pre-increment 784 // RValue<Short4> operator--(Short4 &val, int); // Post-decrement 785 // const Short4 &operator--(Short4 &val); // Pre-decrement 786 // RValue<Bool> operator<(RValue<Short4> lhs, RValue<Short4> rhs); 787 // RValue<Bool> operator<=(RValue<Short4> lhs, RValue<Short4> rhs); 788 // RValue<Bool> operator>(RValue<Short4> lhs, RValue<Short4> rhs); 789 // RValue<Bool> operator>=(RValue<Short4> lhs, RValue<Short4> rhs); 790 // RValue<Bool> operator!=(RValue<Short4> lhs, RValue<Short4> rhs); 791 // RValue<Bool> operator==(RValue<Short4> lhs, RValue<Short4> rhs); 792 793 RValue<Short4> RoundShort4(RValue<Float4> cast); 794 RValue<Short4> Max(RValue<Short4> x, RValue<Short4> y); 795 RValue<Short4> Min(RValue<Short4> x, RValue<Short4> y); 796 RValue<Short4> AddSat(RValue<Short4> x, RValue<Short4> y); 797 RValue<Short4> SubSat(RValue<Short4> x, RValue<Short4> y); 798 RValue<Short4> MulHigh(RValue<Short4> x, RValue<Short4> y); 799 RValue<Int2> MulAdd(RValue<Short4> x, RValue<Short4> y); 800 RValue<SByte8> PackSigned(RValue<Short4> x, RValue<Short4> y); 801 RValue<Byte8> PackUnsigned(RValue<Short4> x, RValue<Short4> y); 802 RValue<Int2> UnpackLow(RValue<Short4> x, RValue<Short4> y); 803 RValue<Int2> UnpackHigh(RValue<Short4> x, RValue<Short4> y); 804 RValue<Short4> Swizzle(RValue<Short4> x, unsigned char select); 805 RValue<Short4> Insert(RValue<Short4> val, RValue<Short> element, int i); 806 RValue<Short> Extract(RValue<Short4> val, int i); 807 RValue<Short4> CmpGT(RValue<Short4> x, RValue<Short4> y); 808 RValue<Short4> CmpEQ(RValue<Short4> x, RValue<Short4> y); 809 810 class UShort4 : public LValue<UShort4> 811 { 812 public: 813 explicit UShort4(RValue<Int4> cast); 814 explicit UShort4(RValue<Float4> cast, bool saturate = false); 815 816 UShort4() = default; 817 UShort4(unsigned short xyzw); 818 UShort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w); 819 UShort4(RValue<UShort4> rhs); 820 UShort4(const UShort4 &rhs); 821 UShort4(const Reference<UShort4> &rhs); 822 UShort4(RValue<Short4> rhs); 823 UShort4(const Short4 &rhs); 824 UShort4(const Reference<Short4> &rhs); 825 826 RValue<UShort4> operator=(RValue<UShort4> rhs); 827 RValue<UShort4> operator=(const UShort4 &rhs); 828 RValue<UShort4> operator=(const Reference<UShort4> &rhs); 829 RValue<UShort4> operator=(RValue<Short4> rhs); 830 RValue<UShort4> operator=(const Short4 &rhs); 831 RValue<UShort4> operator=(const Reference<Short4> &rhs); 832 833 static Type *getType(); 834 }; 835 836 RValue<UShort4> operator+(RValue<UShort4> lhs, RValue<UShort4> rhs); 837 RValue<UShort4> operator-(RValue<UShort4> lhs, RValue<UShort4> rhs); 838 RValue<UShort4> operator*(RValue<UShort4> lhs, RValue<UShort4> rhs); 839 // RValue<UShort4> operator/(RValue<UShort4> lhs, RValue<UShort4> rhs); 840 // RValue<UShort4> operator%(RValue<UShort4> lhs, RValue<UShort4> rhs); 841 RValue<UShort4> operator&(RValue<UShort4> lhs, RValue<UShort4> rhs); 842 RValue<UShort4> operator|(RValue<UShort4> lhs, RValue<UShort4> rhs); 843 RValue<UShort4> operator^(RValue<UShort4> lhs, RValue<UShort4> rhs); 844 RValue<UShort4> operator<<(RValue<UShort4> lhs, unsigned char rhs); 845 RValue<UShort4> operator>>(RValue<UShort4> lhs, unsigned char rhs); 846 // RValue<UShort4> operator+=(UShort4 &lhs, RValue<UShort4> rhs); 847 // RValue<UShort4> operator-=(UShort4 &lhs, RValue<UShort4> rhs); 848 // RValue<UShort4> operator*=(UShort4 &lhs, RValue<UShort4> rhs); 849 // RValue<UShort4> operator/=(UShort4 &lhs, RValue<UShort4> rhs); 850 // RValue<UShort4> operator%=(UShort4 &lhs, RValue<UShort4> rhs); 851 // RValue<UShort4> operator&=(UShort4 &lhs, RValue<UShort4> rhs); 852 // RValue<UShort4> operator|=(UShort4 &lhs, RValue<UShort4> rhs); 853 // RValue<UShort4> operator^=(UShort4 &lhs, RValue<UShort4> rhs); 854 RValue<UShort4> operator<<=(UShort4 &lhs, unsigned char rhs); 855 RValue<UShort4> operator>>=(UShort4 &lhs, unsigned char rhs); 856 // RValue<UShort4> operator+(RValue<UShort4> val); 857 // RValue<UShort4> operator-(RValue<UShort4> val); 858 RValue<UShort4> operator~(RValue<UShort4> val); 859 // RValue<UShort4> operator++(UShort4 &val, int); // Post-increment 860 // const UShort4 &operator++(UShort4 &val); // Pre-increment 861 // RValue<UShort4> operator--(UShort4 &val, int); // Post-decrement 862 // const UShort4 &operator--(UShort4 &val); // Pre-decrement 863 864 RValue<UShort4> Max(RValue<UShort4> x, RValue<UShort4> y); 865 RValue<UShort4> Min(RValue<UShort4> x, RValue<UShort4> y); 866 RValue<UShort4> AddSat(RValue<UShort4> x, RValue<UShort4> y); 867 RValue<UShort4> SubSat(RValue<UShort4> x, RValue<UShort4> y); 868 RValue<UShort4> MulHigh(RValue<UShort4> x, RValue<UShort4> y); 869 RValue<UShort4> Average(RValue<UShort4> x, RValue<UShort4> y); 870 871 class Short8 : public LValue<Short8> 872 { 873 public: 874 Short8() = default; 875 Short8(short c); 876 Short8(short c0, short c1, short c2, short c3, short c4, short c5, short c6, short c7); 877 Short8(RValue<Short8> rhs); 878 // Short8(const Short8 &rhs); 879 Short8(const Reference<Short8> &rhs); 880 Short8(RValue<Short4> lo, RValue<Short4> hi); 881 882 // RValue<Short8> operator=(RValue<Short8> rhs); 883 // RValue<Short8> operator=(const Short8 &rhs); 884 // RValue<Short8> operator=(const Reference<Short8> &rhs); 885 886 static Type *getType(); 887 }; 888 889 RValue<Short8> operator+(RValue<Short8> lhs, RValue<Short8> rhs); 890 // RValue<Short8> operator-(RValue<Short8> lhs, RValue<Short8> rhs); 891 // RValue<Short8> operator*(RValue<Short8> lhs, RValue<Short8> rhs); 892 // RValue<Short8> operator/(RValue<Short8> lhs, RValue<Short8> rhs); 893 // RValue<Short8> operator%(RValue<Short8> lhs, RValue<Short8> rhs); 894 RValue<Short8> operator&(RValue<Short8> lhs, RValue<Short8> rhs); 895 // RValue<Short8> operator|(RValue<Short8> lhs, RValue<Short8> rhs); 896 // RValue<Short8> operator^(RValue<Short8> lhs, RValue<Short8> rhs); 897 RValue<Short8> operator<<(RValue<Short8> lhs, unsigned char rhs); 898 RValue<Short8> operator>>(RValue<Short8> lhs, unsigned char rhs); 899 // RValue<Short8> operator<<(RValue<Short8> lhs, RValue<Short8> rhs); 900 // RValue<Short8> operator>>(RValue<Short8> lhs, RValue<Short8> rhs); 901 // RValue<Short8> operator+=(Short8 &lhs, RValue<Short8> rhs); 902 // RValue<Short8> operator-=(Short8 &lhs, RValue<Short8> rhs); 903 // RValue<Short8> operator*=(Short8 &lhs, RValue<Short8> rhs); 904 // RValue<Short8> operator/=(Short8 &lhs, RValue<Short8> rhs); 905 // RValue<Short8> operator%=(Short8 &lhs, RValue<Short8> rhs); 906 // RValue<Short8> operator&=(Short8 &lhs, RValue<Short8> rhs); 907 // RValue<Short8> operator|=(Short8 &lhs, RValue<Short8> rhs); 908 // RValue<Short8> operator^=(Short8 &lhs, RValue<Short8> rhs); 909 // RValue<Short8> operator<<=(Short8 &lhs, RValue<Short8> rhs); 910 // RValue<Short8> operator>>=(Short8 &lhs, RValue<Short8> rhs); 911 // RValue<Short8> operator+(RValue<Short8> val); 912 // RValue<Short8> operator-(RValue<Short8> val); 913 // RValue<Short8> operator~(RValue<Short8> val); 914 // RValue<Short8> operator++(Short8 &val, int); // Post-increment 915 // const Short8 &operator++(Short8 &val); // Pre-increment 916 // RValue<Short8> operator--(Short8 &val, int); // Post-decrement 917 // const Short8 &operator--(Short8 &val); // Pre-decrement 918 // RValue<Bool> operator<(RValue<Short8> lhs, RValue<Short8> rhs); 919 // RValue<Bool> operator<=(RValue<Short8> lhs, RValue<Short8> rhs); 920 // RValue<Bool> operator>(RValue<Short8> lhs, RValue<Short8> rhs); 921 // RValue<Bool> operator>=(RValue<Short8> lhs, RValue<Short8> rhs); 922 // RValue<Bool> operator!=(RValue<Short8> lhs, RValue<Short8> rhs); 923 // RValue<Bool> operator==(RValue<Short8> lhs, RValue<Short8> rhs); 924 925 RValue<Short8> MulHigh(RValue<Short8> x, RValue<Short8> y); 926 RValue<Int4> MulAdd(RValue<Short8> x, RValue<Short8> y); 927 RValue<Int4> Abs(RValue<Int4> x); 928 929 class UShort8 : public LValue<UShort8> 930 { 931 public: 932 UShort8() = default; 933 UShort8(unsigned short c); 934 UShort8(unsigned short c0, unsigned short c1, unsigned short c2, unsigned short c3, unsigned short c4, unsigned short c5, unsigned short c6, unsigned short c7); 935 UShort8(RValue<UShort8> rhs); 936 // UShort8(const UShort8 &rhs); 937 UShort8(const Reference<UShort8> &rhs); 938 UShort8(RValue<UShort4> lo, RValue<UShort4> hi); 939 940 RValue<UShort8> operator=(RValue<UShort8> rhs); 941 RValue<UShort8> operator=(const UShort8 &rhs); 942 RValue<UShort8> operator=(const Reference<UShort8> &rhs); 943 944 static Type *getType(); 945 }; 946 947 RValue<UShort8> operator+(RValue<UShort8> lhs, RValue<UShort8> rhs); 948 // RValue<UShort8> operator-(RValue<UShort8> lhs, RValue<UShort8> rhs); 949 RValue<UShort8> operator*(RValue<UShort8> lhs, RValue<UShort8> rhs); 950 // RValue<UShort8> operator/(RValue<UShort8> lhs, RValue<UShort8> rhs); 951 // RValue<UShort8> operator%(RValue<UShort8> lhs, RValue<UShort8> rhs); 952 RValue<UShort8> operator&(RValue<UShort8> lhs, RValue<UShort8> rhs); 953 // RValue<UShort8> operator|(RValue<UShort8> lhs, RValue<UShort8> rhs); 954 // RValue<UShort8> operator^(RValue<UShort8> lhs, RValue<UShort8> rhs); 955 RValue<UShort8> operator<<(RValue<UShort8> lhs, unsigned char rhs); 956 RValue<UShort8> operator>>(RValue<UShort8> lhs, unsigned char rhs); 957 // RValue<UShort8> operator<<(RValue<UShort8> lhs, RValue<UShort8> rhs); 958 // RValue<UShort8> operator>>(RValue<UShort8> lhs, RValue<UShort8> rhs); 959 RValue<UShort8> operator+=(UShort8 &lhs, RValue<UShort8> rhs); 960 // RValue<UShort8> operator-=(UShort8 &lhs, RValue<UShort8> rhs); 961 // RValue<UShort8> operator*=(UShort8 &lhs, RValue<UShort8> rhs); 962 // RValue<UShort8> operator/=(UShort8 &lhs, RValue<UShort8> rhs); 963 // RValue<UShort8> operator%=(UShort8 &lhs, RValue<UShort8> rhs); 964 // RValue<UShort8> operator&=(UShort8 &lhs, RValue<UShort8> rhs); 965 // RValue<UShort8> operator|=(UShort8 &lhs, RValue<UShort8> rhs); 966 // RValue<UShort8> operator^=(UShort8 &lhs, RValue<UShort8> rhs); 967 // RValue<UShort8> operator<<=(UShort8 &lhs, RValue<UShort8> rhs); 968 // RValue<UShort8> operator>>=(UShort8 &lhs, RValue<UShort8> rhs); 969 // RValue<UShort8> operator+(RValue<UShort8> val); 970 // RValue<UShort8> operator-(RValue<UShort8> val); 971 RValue<UShort8> operator~(RValue<UShort8> val); 972 // RValue<UShort8> operator++(UShort8 &val, int); // Post-increment 973 // const UShort8 &operator++(UShort8 &val); // Pre-increment 974 // RValue<UShort8> operator--(UShort8 &val, int); // Post-decrement 975 // const UShort8 &operator--(UShort8 &val); // Pre-decrement 976 // RValue<Bool> operator<(RValue<UShort8> lhs, RValue<UShort8> rhs); 977 // RValue<Bool> operator<=(RValue<UShort8> lhs, RValue<UShort8> rhs); 978 // RValue<Bool> operator>(RValue<UShort8> lhs, RValue<UShort8> rhs); 979 // RValue<Bool> operator>=(RValue<UShort8> lhs, RValue<UShort8> rhs); 980 // RValue<Bool> operator!=(RValue<UShort8> lhs, RValue<UShort8> rhs); 981 // RValue<Bool> operator==(RValue<UShort8> lhs, RValue<UShort8> rhs); 982 983 RValue<UShort8> Swizzle(RValue<UShort8> x, char select0, char select1, char select2, char select3, char select4, char select5, char select6, char select7); 984 RValue<UShort8> MulHigh(RValue<UShort8> x, RValue<UShort8> y); 985 986 class Int : public LValue<Int> 987 { 988 public: 989 Int(Argument<Int> argument); 990 991 explicit Int(RValue<Byte> cast); 992 explicit Int(RValue<SByte> cast); 993 explicit Int(RValue<Short> cast); 994 explicit Int(RValue<UShort> cast); 995 explicit Int(RValue<Int2> cast); 996 explicit Int(RValue<Long> cast); 997 explicit Int(RValue<Float> cast); 998 999 Int() = default; 1000 Int(int x); 1001 Int(RValue<Int> rhs); 1002 Int(RValue<UInt> rhs); 1003 Int(const Int &rhs); 1004 Int(const UInt &rhs); 1005 Int(const Reference<Int> &rhs); 1006 Int(const Reference<UInt> &rhs); 1007 1008 RValue<Int> operator=(int rhs); 1009 RValue<Int> operator=(RValue<Int> rhs); 1010 RValue<Int> operator=(RValue<UInt> rhs); 1011 RValue<Int> operator=(const Int &rhs); 1012 RValue<Int> operator=(const UInt &rhs); 1013 RValue<Int> operator=(const Reference<Int> &rhs); 1014 RValue<Int> operator=(const Reference<UInt> &rhs); 1015 1016 static Type *getType(); 1017 }; 1018 1019 RValue<Int> operator+(RValue<Int> lhs, RValue<Int> rhs); 1020 RValue<Int> operator-(RValue<Int> lhs, RValue<Int> rhs); 1021 RValue<Int> operator*(RValue<Int> lhs, RValue<Int> rhs); 1022 RValue<Int> operator/(RValue<Int> lhs, RValue<Int> rhs); 1023 RValue<Int> operator%(RValue<Int> lhs, RValue<Int> rhs); 1024 RValue<Int> operator&(RValue<Int> lhs, RValue<Int> rhs); 1025 RValue<Int> operator|(RValue<Int> lhs, RValue<Int> rhs); 1026 RValue<Int> operator^(RValue<Int> lhs, RValue<Int> rhs); 1027 RValue<Int> operator<<(RValue<Int> lhs, RValue<Int> rhs); 1028 RValue<Int> operator>>(RValue<Int> lhs, RValue<Int> rhs); 1029 RValue<Int> operator+=(Int &lhs, RValue<Int> rhs); 1030 RValue<Int> operator-=(Int &lhs, RValue<Int> rhs); 1031 RValue<Int> operator*=(Int &lhs, RValue<Int> rhs); 1032 RValue<Int> operator/=(Int &lhs, RValue<Int> rhs); 1033 RValue<Int> operator%=(Int &lhs, RValue<Int> rhs); 1034 RValue<Int> operator&=(Int &lhs, RValue<Int> rhs); 1035 RValue<Int> operator|=(Int &lhs, RValue<Int> rhs); 1036 RValue<Int> operator^=(Int &lhs, RValue<Int> rhs); 1037 RValue<Int> operator<<=(Int &lhs, RValue<Int> rhs); 1038 RValue<Int> operator>>=(Int &lhs, RValue<Int> rhs); 1039 RValue<Int> operator+(RValue<Int> val); 1040 RValue<Int> operator-(RValue<Int> val); 1041 RValue<Int> operator~(RValue<Int> val); 1042 RValue<Int> operator++(Int &val, int); // Post-increment 1043 const Int &operator++(Int &val); // Pre-increment 1044 RValue<Int> operator--(Int &val, int); // Post-decrement 1045 const Int &operator--(Int &val); // Pre-decrement 1046 RValue<Bool> operator<(RValue<Int> lhs, RValue<Int> rhs); 1047 RValue<Bool> operator<=(RValue<Int> lhs, RValue<Int> rhs); 1048 RValue<Bool> operator>(RValue<Int> lhs, RValue<Int> rhs); 1049 RValue<Bool> operator>=(RValue<Int> lhs, RValue<Int> rhs); 1050 RValue<Bool> operator!=(RValue<Int> lhs, RValue<Int> rhs); 1051 RValue<Bool> operator==(RValue<Int> lhs, RValue<Int> rhs); 1052 1053 RValue<Int> Max(RValue<Int> x, RValue<Int> y); 1054 RValue<Int> Min(RValue<Int> x, RValue<Int> y); 1055 RValue<Int> Clamp(RValue<Int> x, RValue<Int> min, RValue<Int> max); 1056 RValue<Int> RoundInt(RValue<Float> cast); 1057 1058 class Long : public LValue<Long> 1059 { 1060 public: 1061 // Long(Argument<Long> argument); 1062 1063 // explicit Long(RValue<Short> cast); 1064 // explicit Long(RValue<UShort> cast); 1065 explicit Long(RValue<Int> cast); 1066 explicit Long(RValue<UInt> cast); 1067 // explicit Long(RValue<Float> cast); 1068 1069 Long() = default; 1070 // Long(qword x); 1071 Long(RValue<Long> rhs); 1072 // Long(RValue<ULong> rhs); 1073 // Long(const Long &rhs); 1074 // Long(const Reference<Long> &rhs); 1075 // Long(const ULong &rhs); 1076 // Long(const Reference<ULong> &rhs); 1077 1078 RValue<Long> operator=(int64_t rhs); 1079 RValue<Long> operator=(RValue<Long> rhs); 1080 // RValue<Long> operator=(RValue<ULong> rhs); 1081 RValue<Long> operator=(const Long &rhs); 1082 RValue<Long> operator=(const Reference<Long> &rhs); 1083 // RValue<Long> operator=(const ULong &rhs); 1084 // RValue<Long> operator=(const Reference<ULong> &rhs); 1085 1086 static Type *getType(); 1087 }; 1088 1089 RValue<Long> operator+(RValue<Long> lhs, RValue<Long> rhs); 1090 RValue<Long> operator-(RValue<Long> lhs, RValue<Long> rhs); 1091 // RValue<Long> operator*(RValue<Long> lhs, RValue<Long> rhs); 1092 // RValue<Long> operator/(RValue<Long> lhs, RValue<Long> rhs); 1093 // RValue<Long> operator%(RValue<Long> lhs, RValue<Long> rhs); 1094 // RValue<Long> operator&(RValue<Long> lhs, RValue<Long> rhs); 1095 // RValue<Long> operator|(RValue<Long> lhs, RValue<Long> rhs); 1096 // RValue<Long> operator^(RValue<Long> lhs, RValue<Long> rhs); 1097 // RValue<Long> operator<<(RValue<Long> lhs, RValue<Long> rhs); 1098 // RValue<Long> operator>>(RValue<Long> lhs, RValue<Long> rhs); 1099 RValue<Long> operator+=(Long &lhs, RValue<Long> rhs); 1100 RValue<Long> operator-=(Long &lhs, RValue<Long> rhs); 1101 // RValue<Long> operator*=(Long &lhs, RValue<Long> rhs); 1102 // RValue<Long> operator/=(Long &lhs, RValue<Long> rhs); 1103 // RValue<Long> operator%=(Long &lhs, RValue<Long> rhs); 1104 // RValue<Long> operator&=(Long &lhs, RValue<Long> rhs); 1105 // RValue<Long> operator|=(Long &lhs, RValue<Long> rhs); 1106 // RValue<Long> operator^=(Long &lhs, RValue<Long> rhs); 1107 // RValue<Long> operator<<=(Long &lhs, RValue<Long> rhs); 1108 // RValue<Long> operator>>=(Long &lhs, RValue<Long> rhs); 1109 // RValue<Long> operator+(RValue<Long> val); 1110 // RValue<Long> operator-(RValue<Long> val); 1111 // RValue<Long> operator~(RValue<Long> val); 1112 // RValue<Long> operator++(Long &val, int); // Post-increment 1113 // const Long &operator++(Long &val); // Pre-increment 1114 // RValue<Long> operator--(Long &val, int); // Post-decrement 1115 // const Long &operator--(Long &val); // Pre-decrement 1116 // RValue<Bool> operator<(RValue<Long> lhs, RValue<Long> rhs); 1117 // RValue<Bool> operator<=(RValue<Long> lhs, RValue<Long> rhs); 1118 // RValue<Bool> operator>(RValue<Long> lhs, RValue<Long> rhs); 1119 // RValue<Bool> operator>=(RValue<Long> lhs, RValue<Long> rhs); 1120 // RValue<Bool> operator!=(RValue<Long> lhs, RValue<Long> rhs); 1121 // RValue<Bool> operator==(RValue<Long> lhs, RValue<Long> rhs); 1122 1123 // RValue<Long> RoundLong(RValue<Float> cast); 1124 RValue<Long> AddAtomic( RValue<Pointer<Long>> x, RValue<Long> y); 1125 1126 class UInt : public LValue<UInt> 1127 { 1128 public: 1129 UInt(Argument<UInt> argument); 1130 1131 explicit UInt(RValue<UShort> cast); 1132 explicit UInt(RValue<Long> cast); 1133 explicit UInt(RValue<Float> cast); 1134 1135 UInt() = default; 1136 UInt(int x); 1137 UInt(unsigned int x); 1138 UInt(RValue<UInt> rhs); 1139 UInt(RValue<Int> rhs); 1140 UInt(const UInt &rhs); 1141 UInt(const Int &rhs); 1142 UInt(const Reference<UInt> &rhs); 1143 UInt(const Reference<Int> &rhs); 1144 1145 RValue<UInt> operator=(unsigned int rhs); 1146 RValue<UInt> operator=(RValue<UInt> rhs); 1147 RValue<UInt> operator=(RValue<Int> rhs); 1148 RValue<UInt> operator=(const UInt &rhs); 1149 RValue<UInt> operator=(const Int &rhs); 1150 RValue<UInt> operator=(const Reference<UInt> &rhs); 1151 RValue<UInt> operator=(const Reference<Int> &rhs); 1152 1153 static Type *getType(); 1154 }; 1155 1156 RValue<UInt> operator+(RValue<UInt> lhs, RValue<UInt> rhs); 1157 RValue<UInt> operator-(RValue<UInt> lhs, RValue<UInt> rhs); 1158 RValue<UInt> operator*(RValue<UInt> lhs, RValue<UInt> rhs); 1159 RValue<UInt> operator/(RValue<UInt> lhs, RValue<UInt> rhs); 1160 RValue<UInt> operator%(RValue<UInt> lhs, RValue<UInt> rhs); 1161 RValue<UInt> operator&(RValue<UInt> lhs, RValue<UInt> rhs); 1162 RValue<UInt> operator|(RValue<UInt> lhs, RValue<UInt> rhs); 1163 RValue<UInt> operator^(RValue<UInt> lhs, RValue<UInt> rhs); 1164 RValue<UInt> operator<<(RValue<UInt> lhs, RValue<UInt> rhs); 1165 RValue<UInt> operator>>(RValue<UInt> lhs, RValue<UInt> rhs); 1166 RValue<UInt> operator+=(UInt &lhs, RValue<UInt> rhs); 1167 RValue<UInt> operator-=(UInt &lhs, RValue<UInt> rhs); 1168 RValue<UInt> operator*=(UInt &lhs, RValue<UInt> rhs); 1169 RValue<UInt> operator/=(UInt &lhs, RValue<UInt> rhs); 1170 RValue<UInt> operator%=(UInt &lhs, RValue<UInt> rhs); 1171 RValue<UInt> operator&=(UInt &lhs, RValue<UInt> rhs); 1172 RValue<UInt> operator|=(UInt &lhs, RValue<UInt> rhs); 1173 RValue<UInt> operator^=(UInt &lhs, RValue<UInt> rhs); 1174 RValue<UInt> operator<<=(UInt &lhs, RValue<UInt> rhs); 1175 RValue<UInt> operator>>=(UInt &lhs, RValue<UInt> rhs); 1176 RValue<UInt> operator+(RValue<UInt> val); 1177 RValue<UInt> operator-(RValue<UInt> val); 1178 RValue<UInt> operator~(RValue<UInt> val); 1179 RValue<UInt> operator++(UInt &val, int); // Post-increment 1180 const UInt &operator++(UInt &val); // Pre-increment 1181 RValue<UInt> operator--(UInt &val, int); // Post-decrement 1182 const UInt &operator--(UInt &val); // Pre-decrement 1183 RValue<Bool> operator<(RValue<UInt> lhs, RValue<UInt> rhs); 1184 RValue<Bool> operator<=(RValue<UInt> lhs, RValue<UInt> rhs); 1185 RValue<Bool> operator>(RValue<UInt> lhs, RValue<UInt> rhs); 1186 RValue<Bool> operator>=(RValue<UInt> lhs, RValue<UInt> rhs); 1187 RValue<Bool> operator!=(RValue<UInt> lhs, RValue<UInt> rhs); 1188 RValue<Bool> operator==(RValue<UInt> lhs, RValue<UInt> rhs); 1189 1190 RValue<UInt> Max(RValue<UInt> x, RValue<UInt> y); 1191 RValue<UInt> Min(RValue<UInt> x, RValue<UInt> y); 1192 RValue<UInt> Clamp(RValue<UInt> x, RValue<UInt> min, RValue<UInt> max); 1193 // RValue<UInt> RoundUInt(RValue<Float> cast); 1194 1195 class Int2 : public LValue<Int2> 1196 { 1197 public: 1198 // explicit Int2(RValue<Int> cast); 1199 explicit Int2(RValue<Int4> cast); 1200 1201 Int2() = default; 1202 Int2(int x, int y); 1203 Int2(RValue<Int2> rhs); 1204 Int2(const Int2 &rhs); 1205 Int2(const Reference<Int2> &rhs); 1206 Int2(RValue<Int> lo, RValue<Int> hi); 1207 1208 RValue<Int2> operator=(RValue<Int2> rhs); 1209 RValue<Int2> operator=(const Int2 &rhs); 1210 RValue<Int2> operator=(const Reference<Int2> &rhs); 1211 1212 static Type *getType(); 1213 }; 1214 1215 RValue<Int2> operator+(RValue<Int2> lhs, RValue<Int2> rhs); 1216 RValue<Int2> operator-(RValue<Int2> lhs, RValue<Int2> rhs); 1217 // RValue<Int2> operator*(RValue<Int2> lhs, RValue<Int2> rhs); 1218 // RValue<Int2> operator/(RValue<Int2> lhs, RValue<Int2> rhs); 1219 // RValue<Int2> operator%(RValue<Int2> lhs, RValue<Int2> rhs); 1220 RValue<Int2> operator&(RValue<Int2> lhs, RValue<Int2> rhs); 1221 RValue<Int2> operator|(RValue<Int2> lhs, RValue<Int2> rhs); 1222 RValue<Int2> operator^(RValue<Int2> lhs, RValue<Int2> rhs); 1223 RValue<Int2> operator<<(RValue<Int2> lhs, unsigned char rhs); 1224 RValue<Int2> operator>>(RValue<Int2> lhs, unsigned char rhs); 1225 RValue<Int2> operator+=(Int2 &lhs, RValue<Int2> rhs); 1226 RValue<Int2> operator-=(Int2 &lhs, RValue<Int2> rhs); 1227 // RValue<Int2> operator*=(Int2 &lhs, RValue<Int2> rhs); 1228 // RValue<Int2> operator/=(Int2 &lhs, RValue<Int2> rhs); 1229 // RValue<Int2> operator%=(Int2 &lhs, RValue<Int2> rhs); 1230 RValue<Int2> operator&=(Int2 &lhs, RValue<Int2> rhs); 1231 RValue<Int2> operator|=(Int2 &lhs, RValue<Int2> rhs); 1232 RValue<Int2> operator^=(Int2 &lhs, RValue<Int2> rhs); 1233 RValue<Int2> operator<<=(Int2 &lhs, unsigned char rhs); 1234 RValue<Int2> operator>>=(Int2 &lhs, unsigned char rhs); 1235 // RValue<Int2> operator+(RValue<Int2> val); 1236 // RValue<Int2> operator-(RValue<Int2> val); 1237 RValue<Int2> operator~(RValue<Int2> val); 1238 // RValue<Int2> operator++(Int2 &val, int); // Post-increment 1239 // const Int2 &operator++(Int2 &val); // Pre-increment 1240 // RValue<Int2> operator--(Int2 &val, int); // Post-decrement 1241 // const Int2 &operator--(Int2 &val); // Pre-decrement 1242 // RValue<Bool> operator<(RValue<Int2> lhs, RValue<Int2> rhs); 1243 // RValue<Bool> operator<=(RValue<Int2> lhs, RValue<Int2> rhs); 1244 // RValue<Bool> operator>(RValue<Int2> lhs, RValue<Int2> rhs); 1245 // RValue<Bool> operator>=(RValue<Int2> lhs, RValue<Int2> rhs); 1246 // RValue<Bool> operator!=(RValue<Int2> lhs, RValue<Int2> rhs); 1247 // RValue<Bool> operator==(RValue<Int2> lhs, RValue<Int2> rhs); 1248 1249 // RValue<Int2> RoundInt(RValue<Float4> cast); 1250 RValue<Short4> UnpackLow(RValue<Int2> x, RValue<Int2> y); 1251 RValue<Short4> UnpackHigh(RValue<Int2> x, RValue<Int2> y); 1252 RValue<Int> Extract(RValue<Int2> val, int i); 1253 RValue<Int2> Insert(RValue<Int2> val, RValue<Int> element, int i); 1254 1255 class UInt2 : public LValue<UInt2> 1256 { 1257 public: 1258 UInt2() = default; 1259 UInt2(unsigned int x, unsigned int y); 1260 UInt2(RValue<UInt2> rhs); 1261 UInt2(const UInt2 &rhs); 1262 UInt2(const Reference<UInt2> &rhs); 1263 1264 RValue<UInt2> operator=(RValue<UInt2> rhs); 1265 RValue<UInt2> operator=(const UInt2 &rhs); 1266 RValue<UInt2> operator=(const Reference<UInt2> &rhs); 1267 1268 static Type *getType(); 1269 }; 1270 1271 RValue<UInt2> operator+(RValue<UInt2> lhs, RValue<UInt2> rhs); 1272 RValue<UInt2> operator-(RValue<UInt2> lhs, RValue<UInt2> rhs); 1273 // RValue<UInt2> operator*(RValue<UInt2> lhs, RValue<UInt2> rhs); 1274 // RValue<UInt2> operator/(RValue<UInt2> lhs, RValue<UInt2> rhs); 1275 // RValue<UInt2> operator%(RValue<UInt2> lhs, RValue<UInt2> rhs); 1276 RValue<UInt2> operator&(RValue<UInt2> lhs, RValue<UInt2> rhs); 1277 RValue<UInt2> operator|(RValue<UInt2> lhs, RValue<UInt2> rhs); 1278 RValue<UInt2> operator^(RValue<UInt2> lhs, RValue<UInt2> rhs); 1279 RValue<UInt2> operator<<(RValue<UInt2> lhs, unsigned char rhs); 1280 RValue<UInt2> operator>>(RValue<UInt2> lhs, unsigned char rhs); 1281 RValue<UInt2> operator+=(UInt2 &lhs, RValue<UInt2> rhs); 1282 RValue<UInt2> operator-=(UInt2 &lhs, RValue<UInt2> rhs); 1283 // RValue<UInt2> operator*=(UInt2 &lhs, RValue<UInt2> rhs); 1284 // RValue<UInt2> operator/=(UInt2 &lhs, RValue<UInt2> rhs); 1285 // RValue<UInt2> operator%=(UInt2 &lhs, RValue<UInt2> rhs); 1286 RValue<UInt2> operator&=(UInt2 &lhs, RValue<UInt2> rhs); 1287 RValue<UInt2> operator|=(UInt2 &lhs, RValue<UInt2> rhs); 1288 RValue<UInt2> operator^=(UInt2 &lhs, RValue<UInt2> rhs); 1289 RValue<UInt2> operator<<=(UInt2 &lhs, unsigned char rhs); 1290 RValue<UInt2> operator>>=(UInt2 &lhs, unsigned char rhs); 1291 // RValue<UInt2> operator+(RValue<UInt2> val); 1292 // RValue<UInt2> operator-(RValue<UInt2> val); 1293 RValue<UInt2> operator~(RValue<UInt2> val); 1294 // RValue<UInt2> operator++(UInt2 &val, int); // Post-increment 1295 // const UInt2 &operator++(UInt2 &val); // Pre-increment 1296 // RValue<UInt2> operator--(UInt2 &val, int); // Post-decrement 1297 // const UInt2 &operator--(UInt2 &val); // Pre-decrement 1298 // RValue<Bool> operator<(RValue<UInt2> lhs, RValue<UInt2> rhs); 1299 // RValue<Bool> operator<=(RValue<UInt2> lhs, RValue<UInt2> rhs); 1300 // RValue<Bool> operator>(RValue<UInt2> lhs, RValue<UInt2> rhs); 1301 // RValue<Bool> operator>=(RValue<UInt2> lhs, RValue<UInt2> rhs); 1302 // RValue<Bool> operator!=(RValue<UInt2> lhs, RValue<UInt2> rhs); 1303 // RValue<Bool> operator==(RValue<UInt2> lhs, RValue<UInt2> rhs); 1304 1305 // RValue<UInt2> RoundInt(RValue<Float4> cast); 1306 1307 template<class T> 1308 struct Scalar; 1309 1310 template<class Vector4> 1311 struct XYZW; 1312 1313 template<class Vector4, int T> 1314 class Swizzle2 1315 { 1316 friend Vector4; 1317 1318 public: 1319 operator RValue<Vector4>() const; 1320 1321 private: 1322 Vector4 *parent; 1323 }; 1324 1325 template<class Vector4, int T> 1326 class Swizzle4 1327 { 1328 public: 1329 operator RValue<Vector4>() const; 1330 1331 private: 1332 Vector4 *parent; 1333 }; 1334 1335 template<class Vector4, int T> 1336 class SwizzleMask4 1337 { 1338 friend XYZW<Vector4>; 1339 1340 public: 1341 operator RValue<Vector4>() const; 1342 1343 RValue<Vector4> operator=(RValue<Vector4> rhs); 1344 RValue<Vector4> operator=(RValue<typename Scalar<Vector4>::Type> rhs); 1345 1346 private: 1347 Vector4 *parent; 1348 }; 1349 1350 template<> 1351 struct Scalar<Float4> 1352 { 1353 using Type = Float; 1354 }; 1355 1356 template<> 1357 struct Scalar<Int4> 1358 { 1359 using Type = Int; 1360 }; 1361 1362 template<> 1363 struct Scalar<UInt4> 1364 { 1365 using Type = UInt; 1366 }; 1367 1368 template<class Vector4, int T> 1369 class SwizzleMask1 1370 { 1371 public: 1372 operator RValue<typename Scalar<Vector4>::Type>() const; 1373 operator RValue<Vector4>() const; 1374 1375 RValue<Vector4> operator=(float x); 1376 RValue<Vector4> operator=(RValue<Vector4> rhs); 1377 RValue<Vector4> operator=(RValue<typename Scalar<Vector4>::Type> rhs); 1378 1379 private: 1380 Float4 *parent; 1381 }; 1382 1383 template<class Vector4, int T> 1384 class SwizzleMask2 1385 { 1386 friend class Float4; 1387 1388 public: 1389 operator RValue<Vector4>() const; 1390 1391 RValue<Vector4> operator=(RValue<Vector4> rhs); 1392 1393 private: 1394 Float4 *parent; 1395 }; 1396 1397 template<class Vector4> 1398 struct XYZW 1399 { 1400 friend Vector4; 1401 1402 private: 1403 XYZW(Vector4 *parent) 1404 { 1405 xyzw.parent = parent; 1406 } 1407 1408 public: 1409 union 1410 { 1411 SwizzleMask1<Vector4, 0x00> x; 1412 SwizzleMask1<Vector4, 0x55> y; 1413 SwizzleMask1<Vector4, 0xAA> z; 1414 SwizzleMask1<Vector4, 0xFF> w; 1415 Swizzle2<Vector4, 0x00> xx; 1416 Swizzle2<Vector4, 0x01> yx; 1417 Swizzle2<Vector4, 0x02> zx; 1418 Swizzle2<Vector4, 0x03> wx; 1419 SwizzleMask2<Vector4, 0x54> xy; 1420 Swizzle2<Vector4, 0x55> yy; 1421 Swizzle2<Vector4, 0x56> zy; 1422 Swizzle2<Vector4, 0x57> wy; 1423 SwizzleMask2<Vector4, 0xA8> xz; 1424 SwizzleMask2<Vector4, 0xA9> yz; 1425 Swizzle2<Vector4, 0xAA> zz; 1426 Swizzle2<Vector4, 0xAB> wz; 1427 SwizzleMask2<Vector4, 0xFC> xw; 1428 SwizzleMask2<Vector4, 0xFD> yw; 1429 SwizzleMask2<Vector4, 0xFE> zw; 1430 Swizzle2<Vector4, 0xFF> ww; 1431 Swizzle4<Vector4, 0x00> xxx; 1432 Swizzle4<Vector4, 0x01> yxx; 1433 Swizzle4<Vector4, 0x02> zxx; 1434 Swizzle4<Vector4, 0x03> wxx; 1435 Swizzle4<Vector4, 0x04> xyx; 1436 Swizzle4<Vector4, 0x05> yyx; 1437 Swizzle4<Vector4, 0x06> zyx; 1438 Swizzle4<Vector4, 0x07> wyx; 1439 Swizzle4<Vector4, 0x08> xzx; 1440 Swizzle4<Vector4, 0x09> yzx; 1441 Swizzle4<Vector4, 0x0A> zzx; 1442 Swizzle4<Vector4, 0x0B> wzx; 1443 Swizzle4<Vector4, 0x0C> xwx; 1444 Swizzle4<Vector4, 0x0D> ywx; 1445 Swizzle4<Vector4, 0x0E> zwx; 1446 Swizzle4<Vector4, 0x0F> wwx; 1447 Swizzle4<Vector4, 0x50> xxy; 1448 Swizzle4<Vector4, 0x51> yxy; 1449 Swizzle4<Vector4, 0x52> zxy; 1450 Swizzle4<Vector4, 0x53> wxy; 1451 Swizzle4<Vector4, 0x54> xyy; 1452 Swizzle4<Vector4, 0x55> yyy; 1453 Swizzle4<Vector4, 0x56> zyy; 1454 Swizzle4<Vector4, 0x57> wyy; 1455 Swizzle4<Vector4, 0x58> xzy; 1456 Swizzle4<Vector4, 0x59> yzy; 1457 Swizzle4<Vector4, 0x5A> zzy; 1458 Swizzle4<Vector4, 0x5B> wzy; 1459 Swizzle4<Vector4, 0x5C> xwy; 1460 Swizzle4<Vector4, 0x5D> ywy; 1461 Swizzle4<Vector4, 0x5E> zwy; 1462 Swizzle4<Vector4, 0x5F> wwy; 1463 Swizzle4<Vector4, 0xA0> xxz; 1464 Swizzle4<Vector4, 0xA1> yxz; 1465 Swizzle4<Vector4, 0xA2> zxz; 1466 Swizzle4<Vector4, 0xA3> wxz; 1467 SwizzleMask4<Vector4, 0xA4> xyz; 1468 Swizzle4<Vector4, 0xA5> yyz; 1469 Swizzle4<Vector4, 0xA6> zyz; 1470 Swizzle4<Vector4, 0xA7> wyz; 1471 Swizzle4<Vector4, 0xA8> xzz; 1472 Swizzle4<Vector4, 0xA9> yzz; 1473 Swizzle4<Vector4, 0xAA> zzz; 1474 Swizzle4<Vector4, 0xAB> wzz; 1475 Swizzle4<Vector4, 0xAC> xwz; 1476 Swizzle4<Vector4, 0xAD> ywz; 1477 Swizzle4<Vector4, 0xAE> zwz; 1478 Swizzle4<Vector4, 0xAF> wwz; 1479 Swizzle4<Vector4, 0xF0> xxw; 1480 Swizzle4<Vector4, 0xF1> yxw; 1481 Swizzle4<Vector4, 0xF2> zxw; 1482 Swizzle4<Vector4, 0xF3> wxw; 1483 SwizzleMask4<Vector4, 0xF4> xyw; 1484 Swizzle4<Vector4, 0xF5> yyw; 1485 Swizzle4<Vector4, 0xF6> zyw; 1486 Swizzle4<Vector4, 0xF7> wyw; 1487 SwizzleMask4<Vector4, 0xF8> xzw; 1488 SwizzleMask4<Vector4, 0xF9> yzw; 1489 Swizzle4<Vector4, 0xFA> zzw; 1490 Swizzle4<Vector4, 0xFB> wzw; 1491 Swizzle4<Vector4, 0xFC> xww; 1492 Swizzle4<Vector4, 0xFD> yww; 1493 Swizzle4<Vector4, 0xFE> zww; 1494 Swizzle4<Vector4, 0xFF> www; 1495 Swizzle4<Vector4, 0x00> xxxx; 1496 Swizzle4<Vector4, 0x01> yxxx; 1497 Swizzle4<Vector4, 0x02> zxxx; 1498 Swizzle4<Vector4, 0x03> wxxx; 1499 Swizzle4<Vector4, 0x04> xyxx; 1500 Swizzle4<Vector4, 0x05> yyxx; 1501 Swizzle4<Vector4, 0x06> zyxx; 1502 Swizzle4<Vector4, 0x07> wyxx; 1503 Swizzle4<Vector4, 0x08> xzxx; 1504 Swizzle4<Vector4, 0x09> yzxx; 1505 Swizzle4<Vector4, 0x0A> zzxx; 1506 Swizzle4<Vector4, 0x0B> wzxx; 1507 Swizzle4<Vector4, 0x0C> xwxx; 1508 Swizzle4<Vector4, 0x0D> ywxx; 1509 Swizzle4<Vector4, 0x0E> zwxx; 1510 Swizzle4<Vector4, 0x0F> wwxx; 1511 Swizzle4<Vector4, 0x10> xxyx; 1512 Swizzle4<Vector4, 0x11> yxyx; 1513 Swizzle4<Vector4, 0x12> zxyx; 1514 Swizzle4<Vector4, 0x13> wxyx; 1515 Swizzle4<Vector4, 0x14> xyyx; 1516 Swizzle4<Vector4, 0x15> yyyx; 1517 Swizzle4<Vector4, 0x16> zyyx; 1518 Swizzle4<Vector4, 0x17> wyyx; 1519 Swizzle4<Vector4, 0x18> xzyx; 1520 Swizzle4<Vector4, 0x19> yzyx; 1521 Swizzle4<Vector4, 0x1A> zzyx; 1522 Swizzle4<Vector4, 0x1B> wzyx; 1523 Swizzle4<Vector4, 0x1C> xwyx; 1524 Swizzle4<Vector4, 0x1D> ywyx; 1525 Swizzle4<Vector4, 0x1E> zwyx; 1526 Swizzle4<Vector4, 0x1F> wwyx; 1527 Swizzle4<Vector4, 0x20> xxzx; 1528 Swizzle4<Vector4, 0x21> yxzx; 1529 Swizzle4<Vector4, 0x22> zxzx; 1530 Swizzle4<Vector4, 0x23> wxzx; 1531 Swizzle4<Vector4, 0x24> xyzx; 1532 Swizzle4<Vector4, 0x25> yyzx; 1533 Swizzle4<Vector4, 0x26> zyzx; 1534 Swizzle4<Vector4, 0x27> wyzx; 1535 Swizzle4<Vector4, 0x28> xzzx; 1536 Swizzle4<Vector4, 0x29> yzzx; 1537 Swizzle4<Vector4, 0x2A> zzzx; 1538 Swizzle4<Vector4, 0x2B> wzzx; 1539 Swizzle4<Vector4, 0x2C> xwzx; 1540 Swizzle4<Vector4, 0x2D> ywzx; 1541 Swizzle4<Vector4, 0x2E> zwzx; 1542 Swizzle4<Vector4, 0x2F> wwzx; 1543 Swizzle4<Vector4, 0x30> xxwx; 1544 Swizzle4<Vector4, 0x31> yxwx; 1545 Swizzle4<Vector4, 0x32> zxwx; 1546 Swizzle4<Vector4, 0x33> wxwx; 1547 Swizzle4<Vector4, 0x34> xywx; 1548 Swizzle4<Vector4, 0x35> yywx; 1549 Swizzle4<Vector4, 0x36> zywx; 1550 Swizzle4<Vector4, 0x37> wywx; 1551 Swizzle4<Vector4, 0x38> xzwx; 1552 Swizzle4<Vector4, 0x39> yzwx; 1553 Swizzle4<Vector4, 0x3A> zzwx; 1554 Swizzle4<Vector4, 0x3B> wzwx; 1555 Swizzle4<Vector4, 0x3C> xwwx; 1556 Swizzle4<Vector4, 0x3D> ywwx; 1557 Swizzle4<Vector4, 0x3E> zwwx; 1558 Swizzle4<Vector4, 0x3F> wwwx; 1559 Swizzle4<Vector4, 0x40> xxxy; 1560 Swizzle4<Vector4, 0x41> yxxy; 1561 Swizzle4<Vector4, 0x42> zxxy; 1562 Swizzle4<Vector4, 0x43> wxxy; 1563 Swizzle4<Vector4, 0x44> xyxy; 1564 Swizzle4<Vector4, 0x45> yyxy; 1565 Swizzle4<Vector4, 0x46> zyxy; 1566 Swizzle4<Vector4, 0x47> wyxy; 1567 Swizzle4<Vector4, 0x48> xzxy; 1568 Swizzle4<Vector4, 0x49> yzxy; 1569 Swizzle4<Vector4, 0x4A> zzxy; 1570 Swizzle4<Vector4, 0x4B> wzxy; 1571 Swizzle4<Vector4, 0x4C> xwxy; 1572 Swizzle4<Vector4, 0x4D> ywxy; 1573 Swizzle4<Vector4, 0x4E> zwxy; 1574 Swizzle4<Vector4, 0x4F> wwxy; 1575 Swizzle4<Vector4, 0x50> xxyy; 1576 Swizzle4<Vector4, 0x51> yxyy; 1577 Swizzle4<Vector4, 0x52> zxyy; 1578 Swizzle4<Vector4, 0x53> wxyy; 1579 Swizzle4<Vector4, 0x54> xyyy; 1580 Swizzle4<Vector4, 0x55> yyyy; 1581 Swizzle4<Vector4, 0x56> zyyy; 1582 Swizzle4<Vector4, 0x57> wyyy; 1583 Swizzle4<Vector4, 0x58> xzyy; 1584 Swizzle4<Vector4, 0x59> yzyy; 1585 Swizzle4<Vector4, 0x5A> zzyy; 1586 Swizzle4<Vector4, 0x5B> wzyy; 1587 Swizzle4<Vector4, 0x5C> xwyy; 1588 Swizzle4<Vector4, 0x5D> ywyy; 1589 Swizzle4<Vector4, 0x5E> zwyy; 1590 Swizzle4<Vector4, 0x5F> wwyy; 1591 Swizzle4<Vector4, 0x60> xxzy; 1592 Swizzle4<Vector4, 0x61> yxzy; 1593 Swizzle4<Vector4, 0x62> zxzy; 1594 Swizzle4<Vector4, 0x63> wxzy; 1595 Swizzle4<Vector4, 0x64> xyzy; 1596 Swizzle4<Vector4, 0x65> yyzy; 1597 Swizzle4<Vector4, 0x66> zyzy; 1598 Swizzle4<Vector4, 0x67> wyzy; 1599 Swizzle4<Vector4, 0x68> xzzy; 1600 Swizzle4<Vector4, 0x69> yzzy; 1601 Swizzle4<Vector4, 0x6A> zzzy; 1602 Swizzle4<Vector4, 0x6B> wzzy; 1603 Swizzle4<Vector4, 0x6C> xwzy; 1604 Swizzle4<Vector4, 0x6D> ywzy; 1605 Swizzle4<Vector4, 0x6E> zwzy; 1606 Swizzle4<Vector4, 0x6F> wwzy; 1607 Swizzle4<Vector4, 0x70> xxwy; 1608 Swizzle4<Vector4, 0x71> yxwy; 1609 Swizzle4<Vector4, 0x72> zxwy; 1610 Swizzle4<Vector4, 0x73> wxwy; 1611 Swizzle4<Vector4, 0x74> xywy; 1612 Swizzle4<Vector4, 0x75> yywy; 1613 Swizzle4<Vector4, 0x76> zywy; 1614 Swizzle4<Vector4, 0x77> wywy; 1615 Swizzle4<Vector4, 0x78> xzwy; 1616 Swizzle4<Vector4, 0x79> yzwy; 1617 Swizzle4<Vector4, 0x7A> zzwy; 1618 Swizzle4<Vector4, 0x7B> wzwy; 1619 Swizzle4<Vector4, 0x7C> xwwy; 1620 Swizzle4<Vector4, 0x7D> ywwy; 1621 Swizzle4<Vector4, 0x7E> zwwy; 1622 Swizzle4<Vector4, 0x7F> wwwy; 1623 Swizzle4<Vector4, 0x80> xxxz; 1624 Swizzle4<Vector4, 0x81> yxxz; 1625 Swizzle4<Vector4, 0x82> zxxz; 1626 Swizzle4<Vector4, 0x83> wxxz; 1627 Swizzle4<Vector4, 0x84> xyxz; 1628 Swizzle4<Vector4, 0x85> yyxz; 1629 Swizzle4<Vector4, 0x86> zyxz; 1630 Swizzle4<Vector4, 0x87> wyxz; 1631 Swizzle4<Vector4, 0x88> xzxz; 1632 Swizzle4<Vector4, 0x89> yzxz; 1633 Swizzle4<Vector4, 0x8A> zzxz; 1634 Swizzle4<Vector4, 0x8B> wzxz; 1635 Swizzle4<Vector4, 0x8C> xwxz; 1636 Swizzle4<Vector4, 0x8D> ywxz; 1637 Swizzle4<Vector4, 0x8E> zwxz; 1638 Swizzle4<Vector4, 0x8F> wwxz; 1639 Swizzle4<Vector4, 0x90> xxyz; 1640 Swizzle4<Vector4, 0x91> yxyz; 1641 Swizzle4<Vector4, 0x92> zxyz; 1642 Swizzle4<Vector4, 0x93> wxyz; 1643 Swizzle4<Vector4, 0x94> xyyz; 1644 Swizzle4<Vector4, 0x95> yyyz; 1645 Swizzle4<Vector4, 0x96> zyyz; 1646 Swizzle4<Vector4, 0x97> wyyz; 1647 Swizzle4<Vector4, 0x98> xzyz; 1648 Swizzle4<Vector4, 0x99> yzyz; 1649 Swizzle4<Vector4, 0x9A> zzyz; 1650 Swizzle4<Vector4, 0x9B> wzyz; 1651 Swizzle4<Vector4, 0x9C> xwyz; 1652 Swizzle4<Vector4, 0x9D> ywyz; 1653 Swizzle4<Vector4, 0x9E> zwyz; 1654 Swizzle4<Vector4, 0x9F> wwyz; 1655 Swizzle4<Vector4, 0xA0> xxzz; 1656 Swizzle4<Vector4, 0xA1> yxzz; 1657 Swizzle4<Vector4, 0xA2> zxzz; 1658 Swizzle4<Vector4, 0xA3> wxzz; 1659 Swizzle4<Vector4, 0xA4> xyzz; 1660 Swizzle4<Vector4, 0xA5> yyzz; 1661 Swizzle4<Vector4, 0xA6> zyzz; 1662 Swizzle4<Vector4, 0xA7> wyzz; 1663 Swizzle4<Vector4, 0xA8> xzzz; 1664 Swizzle4<Vector4, 0xA9> yzzz; 1665 Swizzle4<Vector4, 0xAA> zzzz; 1666 Swizzle4<Vector4, 0xAB> wzzz; 1667 Swizzle4<Vector4, 0xAC> xwzz; 1668 Swizzle4<Vector4, 0xAD> ywzz; 1669 Swizzle4<Vector4, 0xAE> zwzz; 1670 Swizzle4<Vector4, 0xAF> wwzz; 1671 Swizzle4<Vector4, 0xB0> xxwz; 1672 Swizzle4<Vector4, 0xB1> yxwz; 1673 Swizzle4<Vector4, 0xB2> zxwz; 1674 Swizzle4<Vector4, 0xB3> wxwz; 1675 Swizzle4<Vector4, 0xB4> xywz; 1676 Swizzle4<Vector4, 0xB5> yywz; 1677 Swizzle4<Vector4, 0xB6> zywz; 1678 Swizzle4<Vector4, 0xB7> wywz; 1679 Swizzle4<Vector4, 0xB8> xzwz; 1680 Swizzle4<Vector4, 0xB9> yzwz; 1681 Swizzle4<Vector4, 0xBA> zzwz; 1682 Swizzle4<Vector4, 0xBB> wzwz; 1683 Swizzle4<Vector4, 0xBC> xwwz; 1684 Swizzle4<Vector4, 0xBD> ywwz; 1685 Swizzle4<Vector4, 0xBE> zwwz; 1686 Swizzle4<Vector4, 0xBF> wwwz; 1687 Swizzle4<Vector4, 0xC0> xxxw; 1688 Swizzle4<Vector4, 0xC1> yxxw; 1689 Swizzle4<Vector4, 0xC2> zxxw; 1690 Swizzle4<Vector4, 0xC3> wxxw; 1691 Swizzle4<Vector4, 0xC4> xyxw; 1692 Swizzle4<Vector4, 0xC5> yyxw; 1693 Swizzle4<Vector4, 0xC6> zyxw; 1694 Swizzle4<Vector4, 0xC7> wyxw; 1695 Swizzle4<Vector4, 0xC8> xzxw; 1696 Swizzle4<Vector4, 0xC9> yzxw; 1697 Swizzle4<Vector4, 0xCA> zzxw; 1698 Swizzle4<Vector4, 0xCB> wzxw; 1699 Swizzle4<Vector4, 0xCC> xwxw; 1700 Swizzle4<Vector4, 0xCD> ywxw; 1701 Swizzle4<Vector4, 0xCE> zwxw; 1702 Swizzle4<Vector4, 0xCF> wwxw; 1703 Swizzle4<Vector4, 0xD0> xxyw; 1704 Swizzle4<Vector4, 0xD1> yxyw; 1705 Swizzle4<Vector4, 0xD2> zxyw; 1706 Swizzle4<Vector4, 0xD3> wxyw; 1707 Swizzle4<Vector4, 0xD4> xyyw; 1708 Swizzle4<Vector4, 0xD5> yyyw; 1709 Swizzle4<Vector4, 0xD6> zyyw; 1710 Swizzle4<Vector4, 0xD7> wyyw; 1711 Swizzle4<Vector4, 0xD8> xzyw; 1712 Swizzle4<Vector4, 0xD9> yzyw; 1713 Swizzle4<Vector4, 0xDA> zzyw; 1714 Swizzle4<Vector4, 0xDB> wzyw; 1715 Swizzle4<Vector4, 0xDC> xwyw; 1716 Swizzle4<Vector4, 0xDD> ywyw; 1717 Swizzle4<Vector4, 0xDE> zwyw; 1718 Swizzle4<Vector4, 0xDF> wwyw; 1719 Swizzle4<Vector4, 0xE0> xxzw; 1720 Swizzle4<Vector4, 0xE1> yxzw; 1721 Swizzle4<Vector4, 0xE2> zxzw; 1722 Swizzle4<Vector4, 0xE3> wxzw; 1723 SwizzleMask4<Vector4, 0xE4> xyzw; 1724 Swizzle4<Vector4, 0xE5> yyzw; 1725 Swizzle4<Vector4, 0xE6> zyzw; 1726 Swizzle4<Vector4, 0xE7> wyzw; 1727 Swizzle4<Vector4, 0xE8> xzzw; 1728 Swizzle4<Vector4, 0xE9> yzzw; 1729 Swizzle4<Vector4, 0xEA> zzzw; 1730 Swizzle4<Vector4, 0xEB> wzzw; 1731 Swizzle4<Vector4, 0xEC> xwzw; 1732 Swizzle4<Vector4, 0xED> ywzw; 1733 Swizzle4<Vector4, 0xEE> zwzw; 1734 Swizzle4<Vector4, 0xEF> wwzw; 1735 Swizzle4<Vector4, 0xF0> xxww; 1736 Swizzle4<Vector4, 0xF1> yxww; 1737 Swizzle4<Vector4, 0xF2> zxww; 1738 Swizzle4<Vector4, 0xF3> wxww; 1739 Swizzle4<Vector4, 0xF4> xyww; 1740 Swizzle4<Vector4, 0xF5> yyww; 1741 Swizzle4<Vector4, 0xF6> zyww; 1742 Swizzle4<Vector4, 0xF7> wyww; 1743 Swizzle4<Vector4, 0xF8> xzww; 1744 Swizzle4<Vector4, 0xF9> yzww; 1745 Swizzle4<Vector4, 0xFA> zzww; 1746 Swizzle4<Vector4, 0xFB> wzww; 1747 Swizzle4<Vector4, 0xFC> xwww; 1748 Swizzle4<Vector4, 0xFD> ywww; 1749 Swizzle4<Vector4, 0xFE> zwww; 1750 Swizzle4<Vector4, 0xFF> wwww; 1751 }; 1752 }; 1753 1754 class Int4 : public LValue<Int4>, public XYZW<Int4> 1755 { 1756 public: 1757 explicit Int4(RValue<Byte4> cast); 1758 explicit Int4(RValue<SByte4> cast); 1759 explicit Int4(RValue<Float4> cast); 1760 explicit Int4(RValue<Short4> cast); 1761 explicit Int4(RValue<UShort4> cast); 1762 1763 Int4(); 1764 Int4(int xyzw); 1765 Int4(int x, int yzw); 1766 Int4(int x, int y, int zw); 1767 Int4(int x, int y, int z, int w); 1768 Int4(RValue<Int4> rhs); 1769 Int4(const Int4 &rhs); 1770 Int4(const Reference<Int4> &rhs); 1771 Int4(RValue<UInt4> rhs); 1772 Int4(const UInt4 &rhs); 1773 Int4(const Reference<UInt4> &rhs); 1774 Int4(RValue<Int2> lo, RValue<Int2> hi); 1775 Int4(RValue<Int> rhs); 1776 Int4(const Int &rhs); 1777 Int4(const Reference<Int> &rhs); 1778 1779 RValue<Int4> operator=(RValue<Int4> rhs); 1780 RValue<Int4> operator=(const Int4 &rhs); 1781 RValue<Int4> operator=(const Reference<Int4> &rhs); 1782 1783 static Type *getType(); 1784 1785 private: 1786 void constant(int x, int y, int z, int w); 1787 }; 1788 1789 RValue<Int4> operator+(RValue<Int4> lhs, RValue<Int4> rhs); 1790 RValue<Int4> operator-(RValue<Int4> lhs, RValue<Int4> rhs); 1791 RValue<Int4> operator*(RValue<Int4> lhs, RValue<Int4> rhs); 1792 RValue<Int4> operator/(RValue<Int4> lhs, RValue<Int4> rhs); 1793 RValue<Int4> operator%(RValue<Int4> lhs, RValue<Int4> rhs); 1794 RValue<Int4> operator&(RValue<Int4> lhs, RValue<Int4> rhs); 1795 RValue<Int4> operator|(RValue<Int4> lhs, RValue<Int4> rhs); 1796 RValue<Int4> operator^(RValue<Int4> lhs, RValue<Int4> rhs); 1797 RValue<Int4> operator<<(RValue<Int4> lhs, unsigned char rhs); 1798 RValue<Int4> operator>>(RValue<Int4> lhs, unsigned char rhs); 1799 RValue<Int4> operator<<(RValue<Int4> lhs, RValue<Int4> rhs); 1800 RValue<Int4> operator>>(RValue<Int4> lhs, RValue<Int4> rhs); 1801 RValue<Int4> operator+=(Int4 &lhs, RValue<Int4> rhs); 1802 RValue<Int4> operator-=(Int4 &lhs, RValue<Int4> rhs); 1803 RValue<Int4> operator*=(Int4 &lhs, RValue<Int4> rhs); 1804 // RValue<Int4> operator/=(Int4 &lhs, RValue<Int4> rhs); 1805 // RValue<Int4> operator%=(Int4 &lhs, RValue<Int4> rhs); 1806 RValue<Int4> operator&=(Int4 &lhs, RValue<Int4> rhs); 1807 RValue<Int4> operator|=(Int4 &lhs, RValue<Int4> rhs); 1808 RValue<Int4> operator^=(Int4 &lhs, RValue<Int4> rhs); 1809 RValue<Int4> operator<<=(Int4 &lhs, unsigned char rhs); 1810 RValue<Int4> operator>>=(Int4 &lhs, unsigned char rhs); 1811 RValue<Int4> operator+(RValue<Int4> val); 1812 RValue<Int4> operator-(RValue<Int4> val); 1813 RValue<Int4> operator~(RValue<Int4> val); 1814 // RValue<Int4> operator++(Int4 &val, int); // Post-increment 1815 // const Int4 &operator++(Int4 &val); // Pre-increment 1816 // RValue<Int4> operator--(Int4 &val, int); // Post-decrement 1817 // const Int4 &operator--(Int4 &val); // Pre-decrement 1818 // RValue<Bool> operator<(RValue<Int4> lhs, RValue<Int4> rhs); 1819 // RValue<Bool> operator<=(RValue<Int4> lhs, RValue<Int4> rhs); 1820 // RValue<Bool> operator>(RValue<Int4> lhs, RValue<Int4> rhs); 1821 // RValue<Bool> operator>=(RValue<Int4> lhs, RValue<Int4> rhs); 1822 // RValue<Bool> operator!=(RValue<Int4> lhs, RValue<Int4> rhs); 1823 // RValue<Bool> operator==(RValue<Int4> lhs, RValue<Int4> rhs); 1824 1825 RValue<Int4> CmpEQ(RValue<Int4> x, RValue<Int4> y); 1826 RValue<Int4> CmpLT(RValue<Int4> x, RValue<Int4> y); 1827 RValue<Int4> CmpLE(RValue<Int4> x, RValue<Int4> y); 1828 RValue<Int4> CmpNEQ(RValue<Int4> x, RValue<Int4> y); 1829 RValue<Int4> CmpNLT(RValue<Int4> x, RValue<Int4> y); 1830 RValue<Int4> CmpNLE(RValue<Int4> x, RValue<Int4> y); 1831 RValue<Int4> Max(RValue<Int4> x, RValue<Int4> y); 1832 RValue<Int4> Min(RValue<Int4> x, RValue<Int4> y); 1833 RValue<Int4> RoundInt(RValue<Float4> cast); 1834 RValue<Short8> PackSigned(RValue<Int4> x, RValue<Int4> y); 1835 RValue<UShort8> PackUnsigned(RValue<Int4> x, RValue<Int4> y); 1836 RValue<Int> Extract(RValue<Int4> val, int i); 1837 RValue<Int4> Insert(RValue<Int4> val, RValue<Int> element, int i); 1838 RValue<Int> SignMask(RValue<Int4> x); 1839 RValue<Int4> Swizzle(RValue<Int4> x, unsigned char select); 1840 1841 class UInt4 : public LValue<UInt4>, public XYZW<UInt4> 1842 { 1843 public: 1844 explicit UInt4(RValue<Float4> cast); 1845 1846 UInt4(); 1847 UInt4(int xyzw); 1848 UInt4(int x, int yzw); 1849 UInt4(int x, int y, int zw); 1850 UInt4(int x, int y, int z, int w); 1851 UInt4(unsigned int x, unsigned int y, unsigned int z, unsigned int w); 1852 UInt4(RValue<UInt4> rhs); 1853 UInt4(const UInt4 &rhs); 1854 UInt4(const Reference<UInt4> &rhs); 1855 UInt4(RValue<Int4> rhs); 1856 UInt4(const Int4 &rhs); 1857 UInt4(const Reference<Int4> &rhs); 1858 UInt4(RValue<UInt2> lo, RValue<UInt2> hi); 1859 1860 RValue<UInt4> operator=(RValue<UInt4> rhs); 1861 RValue<UInt4> operator=(const UInt4 &rhs); 1862 RValue<UInt4> operator=(const Reference<UInt4> &rhs); 1863 1864 static Type *getType(); 1865 1866 private: 1867 void constant(int x, int y, int z, int w); 1868 }; 1869 1870 RValue<UInt4> operator+(RValue<UInt4> lhs, RValue<UInt4> rhs); 1871 RValue<UInt4> operator-(RValue<UInt4> lhs, RValue<UInt4> rhs); 1872 RValue<UInt4> operator*(RValue<UInt4> lhs, RValue<UInt4> rhs); 1873 RValue<UInt4> operator/(RValue<UInt4> lhs, RValue<UInt4> rhs); 1874 RValue<UInt4> operator%(RValue<UInt4> lhs, RValue<UInt4> rhs); 1875 RValue<UInt4> operator&(RValue<UInt4> lhs, RValue<UInt4> rhs); 1876 RValue<UInt4> operator|(RValue<UInt4> lhs, RValue<UInt4> rhs); 1877 RValue<UInt4> operator^(RValue<UInt4> lhs, RValue<UInt4> rhs); 1878 RValue<UInt4> operator<<(RValue<UInt4> lhs, unsigned char rhs); 1879 RValue<UInt4> operator>>(RValue<UInt4> lhs, unsigned char rhs); 1880 RValue<UInt4> operator<<(RValue<UInt4> lhs, RValue<UInt4> rhs); 1881 RValue<UInt4> operator>>(RValue<UInt4> lhs, RValue<UInt4> rhs); 1882 RValue<UInt4> operator+=(UInt4 &lhs, RValue<UInt4> rhs); 1883 RValue<UInt4> operator-=(UInt4 &lhs, RValue<UInt4> rhs); 1884 RValue<UInt4> operator*=(UInt4 &lhs, RValue<UInt4> rhs); 1885 // RValue<UInt4> operator/=(UInt4 &lhs, RValue<UInt4> rhs); 1886 // RValue<UInt4> operator%=(UInt4 &lhs, RValue<UInt4> rhs); 1887 RValue<UInt4> operator&=(UInt4 &lhs, RValue<UInt4> rhs); 1888 RValue<UInt4> operator|=(UInt4 &lhs, RValue<UInt4> rhs); 1889 RValue<UInt4> operator^=(UInt4 &lhs, RValue<UInt4> rhs); 1890 RValue<UInt4> operator<<=(UInt4 &lhs, unsigned char rhs); 1891 RValue<UInt4> operator>>=(UInt4 &lhs, unsigned char rhs); 1892 RValue<UInt4> operator+(RValue<UInt4> val); 1893 RValue<UInt4> operator-(RValue<UInt4> val); 1894 RValue<UInt4> operator~(RValue<UInt4> val); 1895 // RValue<UInt4> operator++(UInt4 &val, int); // Post-increment 1896 // const UInt4 &operator++(UInt4 &val); // Pre-increment 1897 // RValue<UInt4> operator--(UInt4 &val, int); // Post-decrement 1898 // const UInt4 &operator--(UInt4 &val); // Pre-decrement 1899 // RValue<Bool> operator<(RValue<UInt4> lhs, RValue<UInt4> rhs); 1900 // RValue<Bool> operator<=(RValue<UInt4> lhs, RValue<UInt4> rhs); 1901 // RValue<Bool> operator>(RValue<UInt4> lhs, RValue<UInt4> rhs); 1902 // RValue<Bool> operator>=(RValue<UInt4> lhs, RValue<UInt4> rhs); 1903 // RValue<Bool> operator!=(RValue<UInt4> lhs, RValue<UInt4> rhs); 1904 // RValue<Bool> operator==(RValue<UInt4> lhs, RValue<UInt4> rhs); 1905 1906 RValue<UInt4> CmpEQ(RValue<UInt4> x, RValue<UInt4> y); 1907 RValue<UInt4> CmpLT(RValue<UInt4> x, RValue<UInt4> y); 1908 RValue<UInt4> CmpLE(RValue<UInt4> x, RValue<UInt4> y); 1909 RValue<UInt4> CmpNEQ(RValue<UInt4> x, RValue<UInt4> y); 1910 RValue<UInt4> CmpNLT(RValue<UInt4> x, RValue<UInt4> y); 1911 RValue<UInt4> CmpNLE(RValue<UInt4> x, RValue<UInt4> y); 1912 RValue<UInt4> Max(RValue<UInt4> x, RValue<UInt4> y); 1913 RValue<UInt4> Min(RValue<UInt4> x, RValue<UInt4> y); 1914 // RValue<UInt4> RoundInt(RValue<Float4> cast); 1915 1916 class Float : public LValue<Float> 1917 { 1918 public: 1919 explicit Float(RValue<Int> cast); 1920 explicit Float(RValue<UInt> cast); 1921 1922 Float() = default; 1923 Float(float x); 1924 Float(RValue<Float> rhs); 1925 Float(const Float &rhs); 1926 Float(const Reference<Float> &rhs); 1927 1928 template<int T> 1929 Float(const SwizzleMask1<Float4, T> &rhs); 1930 1931 // RValue<Float> operator=(float rhs); // FIXME: Implement 1932 RValue<Float> operator=(RValue<Float> rhs); 1933 RValue<Float> operator=(const Float &rhs); 1934 RValue<Float> operator=(const Reference<Float> &rhs); 1935 1936 template<int T> 1937 RValue<Float> operator=(const SwizzleMask1<Float4, T> &rhs); 1938 1939 static Type *getType(); 1940 }; 1941 1942 RValue<Float> operator+(RValue<Float> lhs, RValue<Float> rhs); 1943 RValue<Float> operator-(RValue<Float> lhs, RValue<Float> rhs); 1944 RValue<Float> operator*(RValue<Float> lhs, RValue<Float> rhs); 1945 RValue<Float> operator/(RValue<Float> lhs, RValue<Float> rhs); 1946 RValue<Float> operator+=(Float &lhs, RValue<Float> rhs); 1947 RValue<Float> operator-=(Float &lhs, RValue<Float> rhs); 1948 RValue<Float> operator*=(Float &lhs, RValue<Float> rhs); 1949 RValue<Float> operator/=(Float &lhs, RValue<Float> rhs); 1950 RValue<Float> operator+(RValue<Float> val); 1951 RValue<Float> operator-(RValue<Float> val); 1952 RValue<Bool> operator<(RValue<Float> lhs, RValue<Float> rhs); 1953 RValue<Bool> operator<=(RValue<Float> lhs, RValue<Float> rhs); 1954 RValue<Bool> operator>(RValue<Float> lhs, RValue<Float> rhs); 1955 RValue<Bool> operator>=(RValue<Float> lhs, RValue<Float> rhs); 1956 RValue<Bool> operator!=(RValue<Float> lhs, RValue<Float> rhs); 1957 RValue<Bool> operator==(RValue<Float> lhs, RValue<Float> rhs); 1958 1959 RValue<Float> Abs(RValue<Float> x); 1960 RValue<Float> Max(RValue<Float> x, RValue<Float> y); 1961 RValue<Float> Min(RValue<Float> x, RValue<Float> y); 1962 RValue<Float> Rcp_pp(RValue<Float> val, bool exactAtPow2 = false); 1963 RValue<Float> RcpSqrt_pp(RValue<Float> val); 1964 RValue<Float> Sqrt(RValue<Float> x); 1965 RValue<Float> Round(RValue<Float> val); 1966 RValue<Float> Trunc(RValue<Float> val); 1967 RValue<Float> Frac(RValue<Float> val); 1968 RValue<Float> Floor(RValue<Float> val); 1969 RValue<Float> Ceil(RValue<Float> val); 1970 1971 class Float2 : public LValue<Float2> 1972 { 1973 public: 1974 // explicit Float2(RValue<Byte2> cast); 1975 // explicit Float2(RValue<Short2> cast); 1976 // explicit Float2(RValue<UShort2> cast); 1977 // explicit Float2(RValue<Int2> cast); 1978 // explicit Float2(RValue<UInt2> cast); 1979 explicit Float2(RValue<Float4> cast); 1980 1981 Float2() = default; 1982 // Float2(float x, float y); 1983 // Float2(RValue<Float2> rhs); 1984 // Float2(const Float2 &rhs); 1985 // Float2(const Reference<Float2> &rhs); 1986 // Float2(RValue<Float> rhs); 1987 // Float2(const Float &rhs); 1988 // Float2(const Reference<Float> &rhs); 1989 1990 // template<int T> 1991 // Float2(const SwizzleMask1<T> &rhs); 1992 1993 // RValue<Float2> operator=(float replicate); 1994 // RValue<Float2> operator=(RValue<Float2> rhs); 1995 // RValue<Float2> operator=(const Float2 &rhs); 1996 // RValue<Float2> operator=(const Reference<Float2> &rhs); 1997 // RValue<Float2> operator=(RValue<Float> rhs); 1998 // RValue<Float2> operator=(const Float &rhs); 1999 // RValue<Float2> operator=(const Reference<Float> &rhs); 2000 2001 // template<int T> 2002 // RValue<Float2> operator=(const SwizzleMask1<T> &rhs); 2003 2004 static Type *getType(); 2005 }; 2006 2007 // RValue<Float2> operator+(RValue<Float2> lhs, RValue<Float2> rhs); 2008 // RValue<Float2> operator-(RValue<Float2> lhs, RValue<Float2> rhs); 2009 // RValue<Float2> operator*(RValue<Float2> lhs, RValue<Float2> rhs); 2010 // RValue<Float2> operator/(RValue<Float2> lhs, RValue<Float2> rhs); 2011 // RValue<Float2> operator%(RValue<Float2> lhs, RValue<Float2> rhs); 2012 // RValue<Float2> operator+=(Float2 &lhs, RValue<Float2> rhs); 2013 // RValue<Float2> operator-=(Float2 &lhs, RValue<Float2> rhs); 2014 // RValue<Float2> operator*=(Float2 &lhs, RValue<Float2> rhs); 2015 // RValue<Float2> operator/=(Float2 &lhs, RValue<Float2> rhs); 2016 // RValue<Float2> operator%=(Float2 &lhs, RValue<Float2> rhs); 2017 // RValue<Float2> operator+(RValue<Float2> val); 2018 // RValue<Float2> operator-(RValue<Float2> val); 2019 2020 // RValue<Float2> Abs(RValue<Float2> x); 2021 // RValue<Float2> Max(RValue<Float2> x, RValue<Float2> y); 2022 // RValue<Float2> Min(RValue<Float2> x, RValue<Float2> y); 2023 // RValue<Float2> Swizzle(RValue<Float2> x, unsigned char select); 2024 // RValue<Float2> Mask(Float2 &lhs, RValue<Float2> rhs, unsigned char select); 2025 2026 class Float4 : public LValue<Float4>, public XYZW<Float4> 2027 { 2028 public: 2029 explicit Float4(RValue<Byte4> cast); 2030 explicit Float4(RValue<SByte4> cast); 2031 explicit Float4(RValue<Short4> cast); 2032 explicit Float4(RValue<UShort4> cast); 2033 explicit Float4(RValue<Int4> cast); 2034 explicit Float4(RValue<UInt4> cast); 2035 2036 Float4(); 2037 Float4(float xyzw); 2038 Float4(float x, float yzw); 2039 Float4(float x, float y, float zw); 2040 Float4(float x, float y, float z, float w); 2041 Float4(RValue<Float4> rhs); 2042 Float4(const Float4 &rhs); 2043 Float4(const Reference<Float4> &rhs); 2044 Float4(RValue<Float> rhs); 2045 Float4(const Float &rhs); 2046 Float4(const Reference<Float> &rhs); 2047 2048 template<int T> 2049 Float4(const SwizzleMask1<Float4, T> &rhs); 2050 template<int T> 2051 Float4(const Swizzle4<Float4, T> &rhs); 2052 template<int X, int Y> 2053 Float4(const Swizzle2<Float4, X> &x, const Swizzle2<Float4, Y> &y); 2054 template<int X, int Y> 2055 Float4(const SwizzleMask2<Float4, X> &x, const Swizzle2<Float4, Y> &y); 2056 template<int X, int Y> 2057 Float4(const Swizzle2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y); 2058 template<int X, int Y> 2059 Float4(const SwizzleMask2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y); 2060 2061 RValue<Float4> operator=(float replicate); 2062 RValue<Float4> operator=(RValue<Float4> rhs); 2063 RValue<Float4> operator=(const Float4 &rhs); 2064 RValue<Float4> operator=(const Reference<Float4> &rhs); 2065 RValue<Float4> operator=(RValue<Float> rhs); 2066 RValue<Float4> operator=(const Float &rhs); 2067 RValue<Float4> operator=(const Reference<Float> &rhs); 2068 2069 template<int T> 2070 RValue<Float4> operator=(const SwizzleMask1<Float4, T> &rhs); 2071 template<int T> 2072 RValue<Float4> operator=(const Swizzle4<Float4, T> &rhs); 2073 2074 static Type *getType(); 2075 2076 private: 2077 void constant(float x, float y, float z, float w); 2078 }; 2079 2080 RValue<Float4> operator+(RValue<Float4> lhs, RValue<Float4> rhs); 2081 RValue<Float4> operator-(RValue<Float4> lhs, RValue<Float4> rhs); 2082 RValue<Float4> operator*(RValue<Float4> lhs, RValue<Float4> rhs); 2083 RValue<Float4> operator/(RValue<Float4> lhs, RValue<Float4> rhs); 2084 RValue<Float4> operator%(RValue<Float4> lhs, RValue<Float4> rhs); 2085 RValue<Float4> operator+=(Float4 &lhs, RValue<Float4> rhs); 2086 RValue<Float4> operator-=(Float4 &lhs, RValue<Float4> rhs); 2087 RValue<Float4> operator*=(Float4 &lhs, RValue<Float4> rhs); 2088 RValue<Float4> operator/=(Float4 &lhs, RValue<Float4> rhs); 2089 RValue<Float4> operator%=(Float4 &lhs, RValue<Float4> rhs); 2090 RValue<Float4> operator+(RValue<Float4> val); 2091 RValue<Float4> operator-(RValue<Float4> val); 2092 2093 RValue<Float4> Abs(RValue<Float4> x); 2094 RValue<Float4> Max(RValue<Float4> x, RValue<Float4> y); 2095 RValue<Float4> Min(RValue<Float4> x, RValue<Float4> y); 2096 RValue<Float4> Rcp_pp(RValue<Float4> val, bool exactAtPow2 = false); 2097 RValue<Float4> RcpSqrt_pp(RValue<Float4> val); 2098 RValue<Float4> Sqrt(RValue<Float4> x); 2099 RValue<Float4> Insert(RValue<Float4> val, RValue<Float> element, int i); 2100 RValue<Float> Extract(RValue<Float4> x, int i); 2101 RValue<Float4> Swizzle(RValue<Float4> x, unsigned char select); 2102 RValue<Float4> ShuffleLowHigh(RValue<Float4> x, RValue<Float4> y, unsigned char imm); 2103 RValue<Float4> UnpackLow(RValue<Float4> x, RValue<Float4> y); 2104 RValue<Float4> UnpackHigh(RValue<Float4> x, RValue<Float4> y); 2105 RValue<Float4> Mask(Float4 &lhs, RValue<Float4> rhs, unsigned char select); 2106 RValue<Int> SignMask(RValue<Float4> x); 2107 RValue<Int4> CmpEQ(RValue<Float4> x, RValue<Float4> y); 2108 RValue<Int4> CmpLT(RValue<Float4> x, RValue<Float4> y); 2109 RValue<Int4> CmpLE(RValue<Float4> x, RValue<Float4> y); 2110 RValue<Int4> CmpNEQ(RValue<Float4> x, RValue<Float4> y); 2111 RValue<Int4> CmpNLT(RValue<Float4> x, RValue<Float4> y); 2112 RValue<Int4> CmpNLE(RValue<Float4> x, RValue<Float4> y); 2113 RValue<Int4> IsInf(RValue<Float4> x); 2114 RValue<Int4> IsNan(RValue<Float4> x); 2115 RValue<Float4> Round(RValue<Float4> x); 2116 RValue<Float4> Trunc(RValue<Float4> x); 2117 RValue<Float4> Frac(RValue<Float4> x); 2118 RValue<Float4> Floor(RValue<Float4> x); 2119 RValue<Float4> Ceil(RValue<Float4> x); 2120 2121 template<class T> 2122 class Pointer : public LValue<Pointer<T>> 2123 { 2124 public: 2125 template<class S> 2126 Pointer(RValue<Pointer<S>> pointerS, int alignment = 1) : alignment(alignment) 2127 { 2128 Value *pointerT = Nucleus::createBitCast(pointerS.value, Nucleus::getPointerType(T::getType())); 2129 LValue<Pointer<T>>::storeValue(pointerT); 2130 } 2131 2132 template<class S> 2133 Pointer(const Pointer<S> &pointer, int alignment = 1) : alignment(alignment) 2134 { 2135 Value *pointerS = pointer.loadValue(); 2136 Value *pointerT = Nucleus::createBitCast(pointerS, Nucleus::getPointerType(T::getType())); 2137 LValue<Pointer<T>>::storeValue(pointerT); 2138 } 2139 2140 Pointer(Argument<Pointer<T>> argument); 2141 2142 Pointer(); 2143 Pointer(RValue<Pointer<T>> rhs); 2144 Pointer(const Pointer<T> &rhs); 2145 Pointer(const Reference<Pointer<T>> &rhs); 2146 2147 RValue<Pointer<T>> operator=(RValue<Pointer<T>> rhs); 2148 RValue<Pointer<T>> operator=(const Pointer<T> &rhs); 2149 RValue<Pointer<T>> operator=(const Reference<Pointer<T>> &rhs); 2150 2151 Reference<T> operator*(); 2152 Reference<T> operator[](int index); 2153 Reference<T> operator[](unsigned int index); 2154 Reference<T> operator[](RValue<Int> index); 2155 Reference<T> operator[](RValue<UInt> index); 2156 2157 static Type *getType(); 2158 2159 private: 2160 const int alignment; 2161 }; 2162 2163 RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, int offset); 2164 RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<Int> offset); 2165 RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<UInt> offset); 2166 RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, int offset); 2167 RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<Int> offset); 2168 RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<UInt> offset); 2169 2170 RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, int offset); 2171 RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, RValue<Int> offset); 2172 RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, RValue<UInt> offset); 2173 RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, int offset); 2174 RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<Int> offset); 2175 RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<UInt> offset); 2176 2177 template<class T, int S = 1> 2178 class Array : public LValue<T> 2179 { 2180 public: 2181 Array(int size = S); 2182 2183 Reference<T> operator[](int index); 2184 Reference<T> operator[](unsigned int index); 2185 Reference<T> operator[](RValue<Int> index); 2186 Reference<T> operator[](RValue<UInt> index); 2187 }; 2188 2189 // RValue<Array<T>> operator++(Array<T> &val, int); // Post-increment 2190 // const Array<T> &operator++(Array<T> &val); // Pre-increment 2191 // RValue<Array<T>> operator--(Array<T> &val, int); // Post-decrement 2192 // const Array<T> &operator--(Array<T> &val); // Pre-decrement 2193 2194 void branch(RValue<Bool> cmp, BasicBlock *bodyBB, BasicBlock *endBB); 2195 2196 void Return(); 2197 void Return(RValue<Int> ret); 2198 2199 template<class T> 2200 void Return(const Pointer<T> &ret); 2201 2202 template<class T> 2203 void Return(RValue<Pointer<T>> ret); 2204 2205 template<unsigned int index, typename... Arguments> 2206 struct ArgI; 2207 2208 template<typename Arg0, typename... Arguments> 2209 struct ArgI<0, Arg0, Arguments...> 2210 { 2211 typedef Arg0 Type; 2212 }; 2213 2214 template<unsigned int index, typename Arg0, typename... Arguments> 2215 struct ArgI<index, Arg0, Arguments...> 2216 { 2217 typedef typename ArgI<index - 1, Arguments...>::Type Type; 2218 }; 2219 2220 // Generic template, leave undefined! 2221 template<typename FunctionType> 2222 class Function; 2223 2224 // Specialized for function types 2225 template<typename Return, typename... Arguments> 2226 class Function<Return(Arguments...)> 2227 { 2228 public: 2229 Function(); 2230 2231 virtual ~Function(); 2232 2233 template<int index> 2234 Argument<typename ArgI<index, Arguments...>::Type> Arg() const 2235 { 2236 Value *arg = Nucleus::getArgument(index); 2237 return Argument<typename ArgI<index, Arguments...>::Type>(arg); 2238 } 2239 2240 Routine *operator()(const wchar_t *name, ...); 2241 2242 protected: 2243 Nucleus *core; 2244 std::vector<Type*> arguments; 2245 }; 2246 2247 template<typename Return> 2248 class Function<Return()> : public Function<Return(Void)> 2249 { 2250 }; 2251 2252 template<int index, typename Return, typename... Arguments> 2253 Argument<typename ArgI<index, Arguments...>::Type> Arg(Function<Return(Arguments...)> &function) 2254 { 2255 return Argument<typename ArgI<index, Arguments...>::Type>(function.arg(index)); 2256 } 2257 2258 RValue<Long> Ticks(); 2259 } 2260 2261 namespace sw 2262 { 2263 template<class T> 2264 LValue<T>::LValue(int arraySize) 2265 { 2266 address = Nucleus::allocateStackVariable(T::getType(), arraySize); 2267 } 2268 2269 template<class T> 2270 Value *LValue<T>::loadValue() const 2271 { 2272 return Nucleus::createLoad(address, T::getType(), false, 0); 2273 } 2274 2275 template<class T> 2276 Value *LValue<T>::storeValue(Value *value) const 2277 { 2278 return Nucleus::createStore(value, address, T::getType(), false, 0); 2279 } 2280 2281 template<class T> 2282 Value *LValue<T>::getAddress(Value *index, bool unsignedIndex) const 2283 { 2284 return Nucleus::createGEP(address, T::getType(), index, unsignedIndex); 2285 } 2286 2287 template<class T> 2288 RValue<Pointer<T>> LValue<T>::operator&() 2289 { 2290 return RValue<Pointer<T>>(address); 2291 } 2292 2293 template<class T> 2294 Reference<T>::Reference(Value *pointer, int alignment) : alignment(alignment) 2295 { 2296 address = pointer; 2297 } 2298 2299 template<class T> 2300 RValue<T> Reference<T>::operator=(RValue<T> rhs) const 2301 { 2302 Nucleus::createStore(rhs.value, address, T::getType(), false, alignment); 2303 2304 return rhs; 2305 } 2306 2307 template<class T> 2308 RValue<T> Reference<T>::operator=(const Reference<T> &ref) const 2309 { 2310 Value *tmp = Nucleus::createLoad(ref.address, T::getType(), false, ref.alignment); 2311 Nucleus::createStore(tmp, address, T::getType(), false, alignment); 2312 2313 return RValue<T>(tmp); 2314 } 2315 2316 template<class T> 2317 RValue<T> Reference<T>::operator+=(RValue<T> rhs) const 2318 { 2319 return *this = *this + rhs; 2320 } 2321 2322 template<class T> 2323 Value *Reference<T>::loadValue() const 2324 { 2325 return Nucleus::createLoad(address, T::getType(), false, alignment); 2326 } 2327 2328 template<class T> 2329 int Reference<T>::getAlignment() const 2330 { 2331 return alignment; 2332 } 2333 2334 template<class T> 2335 RValue<T>::RValue(Value *rvalue) 2336 { 2337 assert(Nucleus::createBitCast(rvalue, T::getType()) == rvalue); // Run-time type should match T, so bitcast is no-op. 2338 2339 value = rvalue; 2340 } 2341 2342 template<class T> 2343 RValue<T>::RValue(const T &lvalue) 2344 { 2345 value = lvalue.loadValue(); 2346 } 2347 2348 template<class T> 2349 RValue<T>::RValue(typename IntLiteral<T>::type i) 2350 { 2351 value = Nucleus::createConstantInt(i); 2352 } 2353 2354 template<class T> 2355 RValue<T>::RValue(typename FloatLiteral<T>::type f) 2356 { 2357 value = Nucleus::createConstantFloat(f); 2358 } 2359 2360 template<class T> 2361 RValue<T>::RValue(const Reference<T> &ref) 2362 { 2363 value = ref.loadValue(); 2364 } 2365 2366 template<class Vector4, int T> 2367 Swizzle2<Vector4, T>::operator RValue<Vector4>() const 2368 { 2369 Value *vector = parent->loadValue(); 2370 2371 return Swizzle(RValue<Vector4>(vector), T); 2372 } 2373 2374 template<class Vector4, int T> 2375 Swizzle4<Vector4, T>::operator RValue<Vector4>() const 2376 { 2377 Value *vector = parent->loadValue(); 2378 2379 return Swizzle(RValue<Vector4>(vector), T); 2380 } 2381 2382 template<class Vector4, int T> 2383 SwizzleMask4<Vector4, T>::operator RValue<Vector4>() const 2384 { 2385 Value *vector = parent->loadValue(); 2386 2387 return Swizzle(RValue<Vector4>(vector), T); 2388 } 2389 2390 template<class Vector4, int T> 2391 RValue<Vector4> SwizzleMask4<Vector4, T>::operator=(RValue<Vector4> rhs) 2392 { 2393 return Mask(*parent, rhs, T); 2394 } 2395 2396 template<class Vector4, int T> 2397 RValue<Vector4> SwizzleMask4<Vector4, T>::operator=(RValue<typename Scalar<Vector4>::Type> rhs) 2398 { 2399 return Mask(*parent, Vector4(rhs), T); 2400 } 2401 2402 template<class Vector4, int T> 2403 SwizzleMask1<Vector4, T>::operator RValue<typename Scalar<Vector4>::Type>() const // FIXME: Call a non-template function 2404 { 2405 return Extract(*parent, T & 0x3); 2406 } 2407 2408 template<class Vector4, int T> 2409 SwizzleMask1<Vector4, T>::operator RValue<Vector4>() const 2410 { 2411 Value *vector = parent->loadValue(); 2412 2413 return Swizzle(RValue<Vector4>(vector), T); 2414 } 2415 2416 template<class Vector4, int T> 2417 RValue<Vector4> SwizzleMask1<Vector4, T>::operator=(float x) 2418 { 2419 return *parent = Insert(*parent, Float(x), T & 0x3); 2420 } 2421 2422 template<class Vector4, int T> 2423 RValue<Vector4> SwizzleMask1<Vector4, T>::operator=(RValue<Vector4> rhs) 2424 { 2425 return Mask(*parent, Float4(rhs), T); 2426 } 2427 2428 template<class Vector4, int T> 2429 RValue<Vector4> SwizzleMask1<Vector4, T>::operator=(RValue<typename Scalar<Vector4>::Type> rhs) // FIXME: Call a non-template function 2430 { 2431 return *parent = Insert(*parent, rhs, T & 0x3); 2432 } 2433 2434 template<class Vector4, int T> 2435 SwizzleMask2<Vector4, T>::operator RValue<Vector4>() const 2436 { 2437 Value *vector = parent->loadValue(); 2438 2439 return Swizzle(RValue<Float4>(vector), T); 2440 } 2441 2442 template<class Vector4, int T> 2443 RValue<Vector4> SwizzleMask2<Vector4, T>::operator=(RValue<Vector4> rhs) 2444 { 2445 return Mask(*parent, Float4(rhs), T); 2446 } 2447 2448 template<int T> 2449 Float::Float(const SwizzleMask1<Float4, T> &rhs) 2450 { 2451 *this = rhs.operator RValue<Float>(); 2452 } 2453 2454 template<int T> 2455 RValue<Float> Float::operator=(const SwizzleMask1<Float4, T> &rhs) 2456 { 2457 return *this = rhs.operator RValue<Float>(); 2458 } 2459 2460 template<int T> 2461 Float4::Float4(const SwizzleMask1<Float4, T> &rhs) : XYZW(this) 2462 { 2463 *this = rhs.operator RValue<Float4>(); 2464 } 2465 2466 template<int T> 2467 Float4::Float4(const Swizzle4<Float4, T> &rhs) : XYZW(this) 2468 { 2469 *this = rhs.operator RValue<Float4>(); 2470 } 2471 2472 template<int X, int Y> 2473 Float4::Float4(const Swizzle2<Float4, X> &x, const Swizzle2<Float4, Y> &y) : XYZW(this) 2474 { 2475 *this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4); 2476 } 2477 2478 template<int X, int Y> 2479 Float4::Float4(const SwizzleMask2<Float4, X> &x, const Swizzle2<Float4, Y> &y) : XYZW(this) 2480 { 2481 *this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4); 2482 } 2483 2484 template<int X, int Y> 2485 Float4::Float4(const Swizzle2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y) : XYZW(this) 2486 { 2487 *this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4); 2488 } 2489 2490 template<int X, int Y> 2491 Float4::Float4(const SwizzleMask2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y) : XYZW(this) 2492 { 2493 *this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4); 2494 } 2495 2496 template<int T> 2497 RValue<Float4> Float4::operator=(const SwizzleMask1<Float4, T> &rhs) 2498 { 2499 return *this = rhs.operator RValue<Float4>(); 2500 } 2501 2502 template<int T> 2503 RValue<Float4> Float4::operator=(const Swizzle4<Float4, T> &rhs) 2504 { 2505 return *this = rhs.operator RValue<Float4>(); 2506 } 2507 2508 template<class T> 2509 Pointer<T>::Pointer(Argument<Pointer<T>> argument) : alignment(1) 2510 { 2511 LValue<Pointer<T>>::storeValue(argument.value); 2512 } 2513 2514 template<class T> 2515 Pointer<T>::Pointer() : alignment(1) 2516 { 2517 LValue<Pointer<T>>::storeValue(Nucleus::createNullPointer(T::getType())); 2518 } 2519 2520 template<class T> 2521 Pointer<T>::Pointer(RValue<Pointer<T>> rhs) : alignment(1) 2522 { 2523 LValue<Pointer<T>>::storeValue(rhs.value); 2524 } 2525 2526 template<class T> 2527 Pointer<T>::Pointer(const Pointer<T> &rhs) : alignment(rhs.alignment) 2528 { 2529 Value *value = rhs.loadValue(); 2530 LValue<Pointer<T>>::storeValue(value); 2531 } 2532 2533 template<class T> 2534 Pointer<T>::Pointer(const Reference<Pointer<T>> &rhs) : alignment(rhs.getAlignment()) 2535 { 2536 Value *value = rhs.loadValue(); 2537 LValue<Pointer<T>>::storeValue(value); 2538 } 2539 2540 template<class T> 2541 RValue<Pointer<T>> Pointer<T>::operator=(RValue<Pointer<T>> rhs) 2542 { 2543 LValue<Pointer<T>>::storeValue(rhs.value); 2544 2545 return rhs; 2546 } 2547 2548 template<class T> 2549 RValue<Pointer<T>> Pointer<T>::operator=(const Pointer<T> &rhs) 2550 { 2551 Value *value = rhs.loadValue(); 2552 LValue<Pointer<T>>::storeValue(value); 2553 2554 return RValue<Pointer<T>>(value); 2555 } 2556 2557 template<class T> 2558 RValue<Pointer<T>> Pointer<T>::operator=(const Reference<Pointer<T>> &rhs) 2559 { 2560 Value *value = rhs.loadValue(); 2561 LValue<Pointer<T>>::storeValue(value); 2562 2563 return RValue<Pointer<T>>(value); 2564 } 2565 2566 template<class T> 2567 Reference<T> Pointer<T>::operator*() 2568 { 2569 return Reference<T>(LValue<Pointer<T>>::loadValue(), alignment); 2570 } 2571 2572 template<class T> 2573 Reference<T> Pointer<T>::operator[](int index) 2574 { 2575 Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), Nucleus::createConstantInt(index), false); 2576 2577 return Reference<T>(element, alignment); 2578 } 2579 2580 template<class T> 2581 Reference<T> Pointer<T>::operator[](unsigned int index) 2582 { 2583 Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), Nucleus::createConstantInt(index), true); 2584 2585 return Reference<T>(element, alignment); 2586 } 2587 2588 template<class T> 2589 Reference<T> Pointer<T>::operator[](RValue<Int> index) 2590 { 2591 Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), index.value, false); 2592 2593 return Reference<T>(element, alignment); 2594 } 2595 2596 template<class T> 2597 Reference<T> Pointer<T>::operator[](RValue<UInt> index) 2598 { 2599 Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), index.value, true); 2600 2601 return Reference<T>(element, alignment); 2602 } 2603 2604 template<class T> 2605 Type *Pointer<T>::getType() 2606 { 2607 return Nucleus::getPointerType(T::getType()); 2608 } 2609 2610 template<class T, int S> 2611 Array<T, S>::Array(int size) : LValue<T>(size) 2612 { 2613 } 2614 2615 template<class T, int S> 2616 Reference<T> Array<T, S>::operator[](int index) 2617 { 2618 Value *element = LValue<T>::getAddress(Nucleus::createConstantInt(index), false); 2619 2620 return Reference<T>(element); 2621 } 2622 2623 template<class T, int S> 2624 Reference<T> Array<T, S>::operator[](unsigned int index) 2625 { 2626 Value *element = LValue<T>::getAddress(Nucleus::createConstantInt(index), true); 2627 2628 return Reference<T>(element); 2629 } 2630 2631 template<class T, int S> 2632 Reference<T> Array<T, S>::operator[](RValue<Int> index) 2633 { 2634 Value *element = LValue<T>::getAddress(index.value, false); 2635 2636 return Reference<T>(element); 2637 } 2638 2639 template<class T, int S> 2640 Reference<T> Array<T, S>::operator[](RValue<UInt> index) 2641 { 2642 Value *element = LValue<T>::getAddress(index.value, true); 2643 2644 return Reference<T>(element); 2645 } 2646 2647 // template<class T> 2648 // RValue<Array<T>> operator++(Array<T> &val, int) 2649 // { 2650 // // FIXME: Requires storing the address of the array 2651 // } 2652 2653 // template<class T> 2654 // const Array<T> &operator++(Array<T> &val) 2655 // { 2656 // // FIXME: Requires storing the address of the array 2657 // } 2658 2659 // template<class T> 2660 // RValue<Array<T>> operator--(Array<T> &val, int) 2661 // { 2662 // // FIXME: Requires storing the address of the array 2663 // } 2664 2665 // template<class T> 2666 // const Array<T> &operator--(Array<T> &val) 2667 // { 2668 // // FIXME: Requires storing the address of the array 2669 // } 2670 2671 template<class T> 2672 RValue<T> IfThenElse(RValue<Bool> condition, RValue<T> ifTrue, RValue<T> ifFalse) 2673 { 2674 return RValue<T>(Nucleus::createSelect(condition.value, ifTrue.value, ifFalse.value)); 2675 } 2676 2677 template<class T> 2678 RValue<T> IfThenElse(RValue<Bool> condition, const T &ifTrue, RValue<T> ifFalse) 2679 { 2680 Value *trueValue = ifTrue.loadValue(); 2681 2682 return RValue<T>(Nucleus::createSelect(condition.value, trueValue, ifFalse.value)); 2683 } 2684 2685 template<class T> 2686 RValue<T> IfThenElse(RValue<Bool> condition, RValue<T> ifTrue, const T &ifFalse) 2687 { 2688 Value *falseValue = ifFalse.loadValue(); 2689 2690 return RValue<T>(Nucleus::createSelect(condition.value, ifTrue.value, falseValue)); 2691 } 2692 2693 template<class T> 2694 RValue<T> IfThenElse(RValue<Bool> condition, const T &ifTrue, const T &ifFalse) 2695 { 2696 Value *trueValue = ifTrue.loadValue(); 2697 Value *falseValue = ifFalse.loadValue(); 2698 2699 return RValue<T>(Nucleus::createSelect(condition.value, trueValue, falseValue)); 2700 } 2701 2702 template<class T> 2703 void Return(const Pointer<T> &ret) 2704 { 2705 Nucleus::createRet(Nucleus::createLoad(ret.address, Pointer<T>::getType())); 2706 Nucleus::setInsertBlock(Nucleus::createBasicBlock()); 2707 } 2708 2709 template<class T> 2710 void Return(RValue<Pointer<T>> ret) 2711 { 2712 Nucleus::createRet(ret.value); 2713 Nucleus::setInsertBlock(Nucleus::createBasicBlock()); 2714 } 2715 2716 template<typename Return, typename... Arguments> 2717 Function<Return(Arguments...)>::Function() 2718 { 2719 core = new Nucleus(); 2720 2721 Type *types[] = {Arguments::getType()...}; 2722 for(Type *type : types) 2723 { 2724 if(type != Void::getType()) 2725 { 2726 arguments.push_back(type); 2727 } 2728 } 2729 2730 Nucleus::createFunction(Return::getType(), arguments); 2731 } 2732 2733 template<typename Return, typename... Arguments> 2734 Function<Return(Arguments...)>::~Function() 2735 { 2736 delete core; 2737 } 2738 2739 template<typename Return, typename... Arguments> 2740 Routine *Function<Return(Arguments...)>::operator()(const wchar_t *name, ...) 2741 { 2742 wchar_t fullName[1024 + 1]; 2743 2744 va_list vararg; 2745 va_start(vararg, name); 2746 vswprintf(fullName, 1024, name, vararg); 2747 va_end(vararg); 2748 2749 return core->acquireRoutine(fullName, true); 2750 } 2751 2752 template<class T, class S> 2753 RValue<T> ReinterpretCast(RValue<S> val) 2754 { 2755 return RValue<T>(Nucleus::createBitCast(val.value, T::getType())); 2756 } 2757 2758 template<class T, class S> 2759 RValue<T> ReinterpretCast(const LValue<S> &var) 2760 { 2761 Value *val = var.loadValue(); 2762 2763 return RValue<T>(Nucleus::createBitCast(val, T::getType())); 2764 } 2765 2766 template<class T, class S> 2767 RValue<T> ReinterpretCast(const Reference<S> &var) 2768 { 2769 return ReinterpretCast<T>(RValue<S>(var)); 2770 } 2771 2772 template<class T> 2773 RValue<T> As(Value *val) 2774 { 2775 return RValue<T>(Nucleus::createBitCast(val, T::getType())); 2776 } 2777 2778 template<class T, class S> 2779 RValue<T> As(RValue<S> val) 2780 { 2781 return ReinterpretCast<T>(val); 2782 } 2783 2784 template<class T, class S> 2785 RValue<T> As(const LValue<S> &var) 2786 { 2787 return ReinterpretCast<T>(var); 2788 } 2789 2790 template<class T, class S> 2791 RValue<T> As(const Reference<S> &val) 2792 { 2793 return ReinterpretCast<T>(val); 2794 } 2795 2796 class ForData 2797 { 2798 public: 2799 ForData(bool init) : loopOnce(init) 2800 { 2801 } 2802 2803 operator bool() 2804 { 2805 return loopOnce; 2806 } 2807 2808 bool operator=(bool value) 2809 { 2810 return loopOnce = value; 2811 } 2812 2813 bool setup() 2814 { 2815 if(Nucleus::getInsertBlock() != endBB) 2816 { 2817 testBB = Nucleus::createBasicBlock(); 2818 2819 Nucleus::createBr(testBB); 2820 Nucleus::setInsertBlock(testBB); 2821 2822 return true; 2823 } 2824 2825 return false; 2826 } 2827 2828 bool test(RValue<Bool> cmp) 2829 { 2830 BasicBlock *bodyBB = Nucleus::createBasicBlock(); 2831 endBB = Nucleus::createBasicBlock(); 2832 2833 Nucleus::createCondBr(cmp.value, bodyBB, endBB); 2834 Nucleus::setInsertBlock(bodyBB); 2835 2836 return true; 2837 } 2838 2839 void end() 2840 { 2841 Nucleus::createBr(testBB); 2842 Nucleus::setInsertBlock(endBB); 2843 } 2844 2845 private: 2846 BasicBlock *testBB = nullptr; 2847 BasicBlock *endBB = nullptr; 2848 bool loopOnce = true; 2849 }; 2850 2851 class IfElseData 2852 { 2853 public: 2854 IfElseData(RValue<Bool> cmp) : iteration(0) 2855 { 2856 condition = cmp.value; 2857 2858 beginBB = Nucleus::getInsertBlock(); 2859 trueBB = Nucleus::createBasicBlock(); 2860 falseBB = nullptr; 2861 endBB = Nucleus::createBasicBlock(); 2862 2863 Nucleus::setInsertBlock(trueBB); 2864 } 2865 2866 ~IfElseData() 2867 { 2868 Nucleus::createBr(endBB); 2869 2870 Nucleus::setInsertBlock(beginBB); 2871 Nucleus::createCondBr(condition, trueBB, falseBB ? falseBB : endBB); 2872 2873 Nucleus::setInsertBlock(endBB); 2874 } 2875 2876 operator int() 2877 { 2878 return iteration; 2879 } 2880 2881 IfElseData &operator++() 2882 { 2883 ++iteration; 2884 2885 return *this; 2886 } 2887 2888 void elseClause() 2889 { 2890 Nucleus::createBr(endBB); 2891 2892 falseBB = Nucleus::createBasicBlock(); 2893 Nucleus::setInsertBlock(falseBB); 2894 } 2895 2896 private: 2897 Value *condition; 2898 BasicBlock *beginBB; 2899 BasicBlock *trueBB; 2900 BasicBlock *falseBB; 2901 BasicBlock *endBB; 2902 int iteration; 2903 }; 2904 2905 #define For(init, cond, inc) \ 2906 for(ForData for__ = true; for__; for__ = false) \ 2907 for(init; for__.setup() && for__.test(cond); inc, for__.end()) 2908 2909 #define While(cond) For((void)0, cond, (void)0) 2910 2911 #define Do \ 2912 { \ 2913 BasicBlock *body__ = Nucleus::createBasicBlock(); \ 2914 Nucleus::createBr(body__); \ 2915 Nucleus::setInsertBlock(body__); 2916 2917 #define Until(cond) \ 2918 BasicBlock *end__ = Nucleus::createBasicBlock(); \ 2919 Nucleus::createCondBr((cond).value, end__, body__); \ 2920 Nucleus::setInsertBlock(end__); \ 2921 } 2922 2923 enum {IF_BLOCK__, ELSE_CLAUSE__, ELSE_BLOCK__, IFELSE_NUM__}; 2924 2925 #define If(cond) \ 2926 for(IfElseData ifElse__(cond); ifElse__ < IFELSE_NUM__; ++ifElse__) \ 2927 if(ifElse__ == IF_BLOCK__) 2928 2929 #define Else \ 2930 else if(ifElse__ == ELSE_CLAUSE__) \ 2931 { \ 2932 ifElse__.elseClause(); \ 2933 } \ 2934 else // ELSE_BLOCK__ 2935 } 2936 2937 #endif // sw_Reactor_hpp 2938
