IR: Remove Int128.

Author: caozhanhao

include/ir/base.hpp

@@ -24,8 +24,6 @@
 
 #include "type.hpp"
 #include "type_alias.hpp"
-#include "utils/int128.hpp"
-#include "utils/int128.hpp"
 #include "utils/iterator.hpp"
 #include "utils/misc.hpp"
 
@@ -384,10 +382,6 @@ class User : public Value {
 
 template <typename T> std::string toIRString(T value) { return std::to_string(value); }
 
-template <> inline std::string toIRString(int128_t value) {
-    return Int128ToString(value);
-}
-
 // Maybe there is some historical reasons :(
 // See https://llvm.org/docs/LangRef.html and https://groups.google.com/g/llvm-dev/c/IlqV3TbSk6M?pli=1
 // A Useful Tool: https://www.h-schmidt.net/FloatConverter/IEEE754.html

include/ir/constant.hpp

@@ -10,7 +10,6 @@
 #define GNALC_IR_CONSTANT_HPP
 
 #include "base.hpp"
-#include "utils/int128.hpp"
 
 #include <variant>
 
@@ -79,7 +78,6 @@ using ConstantI1 = detail::BasicConstant<bool, IRBTYPE::I1>;
 using ConstantI8 = detail::BasicConstant<char, IRBTYPE::I8>;
 using ConstantInt = detail::BasicConstant<int, IRBTYPE::I32>;
 using ConstantI64 = detail::BasicConstant<int64_t, IRBTYPE::I64>;
-using ConstantI128 = detail::BasicConstant<int128_t, IRBTYPE::I128>;
 using ConstantFloat = detail::BasicConstant<float, IRBTYPE::FLOAT>;
 using ConstantIntVector = detail::BasicConstantVector<int, IRBTYPE::I32>;
 using ConstantFloatVector = detail::BasicConstantVector<float, IRBTYPE::FLOAT>;
@@ -88,7 +86,6 @@ using pConstI1 = std::shared_ptr<ConstantI1>;
 using pConstI8 = std::shared_ptr<ConstantI8>;
 using pConstI32 = std::shared_ptr<ConstantInt>;
 using pConstI64 = std::shared_ptr<ConstantI64>;
-using pConstI128 = std::shared_ptr<ConstantI128>;
 using pConstF32 = std::shared_ptr<ConstantFloat>;
 using pConstI32Vec = std::shared_ptr<ConstantIntVector>;
 using pConstF32Vec = std::shared_ptr<ConstantFloatVector>;
@@ -108,8 +105,6 @@ template <typename T> auto getIRConstantTypeHelper() {
         return ConstantInt(0);
     else if constexpr (std::is_same_v<U, int64_t>)
         return ConstantI64(0);
-    else if constexpr (std::is_same_v<U, int128_t>)
-        return ConstantI128(0);
     else if constexpr (std::is_same_v<U, float>)
         return ConstantFloat(0);
 }

include/ir/constant_pool.hpp

@@ -31,7 +31,6 @@ class ConstantPool {
     pConstI8 getConst(char val);
     pConstI32 getConst(int val);
     pConstI64 getConst(int64_t val);
-    pConstI128 getConst(int128_t val);
     pConstF32 getConst(float val);
     pConstI32Vec getConst(const std::vector<int>& val);
     pConstF32Vec getConst(const std::vector<float>& val);

include/ir/constant_proxy.hpp

@@ -26,8 +26,7 @@ class ConstantProxyHash;
 class ConstantProxy {
     friend class ConstantProxyHash;
 
-    std::variant<pConstI1, pConstI8, pConstI32, pConstI64, pConstI128,
-        pConstF32, pConstI32Vec, pConstF32Vec> value;
+    std::variant<pConstI1, pConstI8, pConstI32, pConstI64, pConstF32, pConstI32Vec, pConstF32Vec> value;
 
     ConstantPool *pool;
 
@@ -42,7 +41,6 @@ class ConstantProxy {
     explicit ConstantProxy(ConstantPool *pool_, pConstI8 value_);
     explicit ConstantProxy(ConstantPool *pool_, pConstI32 value_);
     explicit ConstantProxy(ConstantPool *pool_, pConstI64 value_);
-    explicit ConstantProxy(ConstantPool *pool_, pConstI128 value_);
     explicit ConstantProxy(ConstantPool *pool_, pConstF32 value_);
     explicit ConstantProxy(ConstantPool *pool_, pConstI32Vec value_);
     explicit ConstantProxy(ConstantPool *pool_, pConstF32Vec value_);
@@ -53,7 +51,6 @@ class ConstantProxy {
     explicit ConstantProxy(ConstantPool *pool_, char value_);
     explicit ConstantProxy(ConstantPool *pool_, int value_);
     explicit ConstantProxy(ConstantPool *pool_, int64_t value_);
-    explicit ConstantProxy(ConstantPool *pool_, int128_t value_);
     explicit ConstantProxy(ConstantPool *pool_, float value_);
     explicit ConstantProxy(ConstantPool *pool_, const std::vector<int>& value_);
     explicit ConstantProxy(ConstantPool *pool_, const std::vector<float>& value_);
@@ -88,14 +85,12 @@ class ConstantProxy {
     bool operator==(char rhs) const;
     bool operator==(int rhs) const;
     bool operator==(int64_t rhs) const;
-    bool operator==(int128_t rhs) const;
     bool operator==(float rhs) const;
 
     pConstI1 getConstantI1() const;
     pConstI8 getConstantI8() const;
     pConstI32 getConstantInt() const;
     pConstI64 getConstantI64() const;
-    pConstI128 getConstantI128() const;
     pConstF32 getConstantFloat() const;
     pConstI32Vec getConstantIntVector() const;
     pConstF32Vec getConstantFloatVector() const;
@@ -106,7 +101,6 @@ class ConstantProxy {
     char get_i8() const;
     int get_int() const;
     int64_t get_i64() const;
-    int128_t get_i128() const;
     float get_float() const;
     std::vector<int> get_i32_vector() const;
     std::vector<float> get_f32_vector() const;

include/ir/target/armv7.hpp

@@ -34,7 +34,7 @@ class ARMv7TargetInfo : public TargetInfo {
         return true;
     }
     bool isTypeSupported(const pType &type) const override {
-        if (type->isI64() || type->isI128())
+        if (type->isI64())
             return false;
         return true;
     }

include/ir/target/armv8.hpp

@@ -14,8 +14,6 @@ class ARMv8TargetInfo : public TargetInfo {
 public:
     bool isInstSupported(OP op) const override { return true; }
     bool isTypeSupported(const pType &type) const override {
-        if (type->isI128())
-            return false;
         return true;
     }
     bool isIntrinsicSupported(const std::string &lib_fn_name) const override { return true; }

include/ir/target/riscv64.hpp

@@ -26,8 +26,6 @@ class RV64TargetInfo : public TargetInfo {
         return true;
     }
     bool isTypeSupported(const pType &type) const override {
-        if (type->isI128())
-            return false;
         return true;
     }
 

include/ir/type.hpp

@@ -26,7 +26,6 @@ enum class IRBTYPE {
     I8, // For sylib's putf(char a[], ...)
     I32,
     I64,
-    I128,
     FLOAT,
     VOID,
     UNDEFINED
@@ -47,8 +46,6 @@ inline size_t getBytes(IRBTYPE type) {
         return 4;
     case IRBTYPE::I64:
         return 8;
-    case IRBTYPE::I128:
-        return 16;
     default:
         Err::error("In IR::BType::getBytes(): illegal type.");
         return 0;
@@ -93,7 +90,6 @@ class Type : public std::enable_shared_from_this<Type> {
     bool isI8() const;
     bool isI32() const;
     bool isI64() const;
-    bool isI128() const;
     bool isF32() const;
     bool isInteger() const;
     bool isFloatingPoint() const;
@@ -130,8 +126,6 @@ class BType : public Type {
             return "i32";
         case IRBTYPE::I64:
             return "i64";
-        case IRBTYPE::I128:
-            return "i128";
         case IRBTYPE::FLOAT:
             return "float";
         case IRBTYPE::VOID:

include/ir/visitor.hpp

@@ -41,7 +41,6 @@ class IRVisitor {
     virtual void visit(ConstantI8 &node) { Err::not_implemented("IRVisitor::visit(ConstantI8&)"); }
     virtual void visit(ConstantInt &node) { Err::not_implemented("IRVisitor::visit(ConstantInt&)"); }
     virtual void visit(ConstantI64 &node) { Err::not_implemented("IRVisitor::visit(ConstantI64&)"); }
-    virtual void visit(ConstantI128 &node) { Err::not_implemented("IRVisitor::visit(ConstantI128&)"); }
     virtual void visit(ConstantFloat &node) { Err::not_implemented("IRVisitor::visit(ConstantFloat&)"); }
     virtual void visit(ConstantIntVector &node) { Err::not_implemented("IRVisitor::visit(ConstantIntVector&)"); }
     virtual void visit(ConstantFloatVector &node) { Err::not_implemented("IRVisitor::visit(ConstantFloatVector&)"); }