[clang] 4bae636 - Revert "[clang][Interp] Add IntegralAP for arbitrary-precision integers (#65844)"
Timm Bäder via cfe-commits
cfe-commits at lists.llvm.org
Sat Sep 30 11:12:35 PDT 2023
Author: Timm Bäder
Date: 2023-09-30T20:12:14+02:00
New Revision: 4bae636abfe4d9ef4b778fc3e4ea0a3fc33e2f37
URL: https://github.com/llvm/llvm-project/commit/4bae636abfe4d9ef4b778fc3e4ea0a3fc33e2f37
DIFF: https://github.com/llvm/llvm-project/commit/4bae636abfe4d9ef4b778fc3e4ea0a3fc33e2f37.diff
LOG: Revert "[clang][Interp] Add IntegralAP for arbitrary-precision integers (#65844)"
This reverts commit 16b9e6fbac4c0bd94c66e7670a41b5c266cf7bff.
This breaks buildbots.
Added:
Modified:
clang/lib/AST/Interp/ByteCodeExprGen.cpp
clang/lib/AST/Interp/Context.cpp
clang/lib/AST/Interp/Descriptor.cpp
clang/lib/AST/Interp/EvalEmitter.cpp
clang/lib/AST/Interp/Integral.h
clang/lib/AST/Interp/Interp.h
clang/lib/AST/Interp/InterpStack.h
clang/lib/AST/Interp/Opcodes.td
clang/lib/AST/Interp/PrimType.cpp
clang/lib/AST/Interp/PrimType.h
clang/test/AST/Interp/literals.cpp
Removed:
clang/lib/AST/Interp/IntegralAP.h
################################################################################
diff --git a/clang/lib/AST/Interp/ByteCodeExprGen.cpp b/clang/lib/AST/Interp/ByteCodeExprGen.cpp
index 4b251931aa01d8a..46906377863bd74 100644
--- a/clang/lib/AST/Interp/ByteCodeExprGen.cpp
+++ b/clang/lib/AST/Interp/ByteCodeExprGen.cpp
@@ -171,17 +171,14 @@ bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
return this->discard(SubExpr);
std::optional<PrimType> FromT = classify(SubExpr->getType());
std::optional<PrimType> ToT = classify(CE->getType());
-
if (!FromT || !ToT)
return false;
if (!this->visit(SubExpr))
return false;
- if (FromT == ToT) {
- assert(ToT != PT_IntAP && ToT != PT_IntAPS);
+ if (FromT == ToT)
return true;
- }
return this->emitCast(*FromT, *ToT, CE);
}
@@ -1641,9 +1638,6 @@ bool ByteCodeExprGen<Emitter>::visitZeroInitializer(QualType QT,
return this->emitZeroSint64(E);
case PT_Uint64:
return this->emitZeroUint64(E);
- case PT_IntAP:
- case PT_IntAPS:
- assert(false);
case PT_Ptr:
return this->emitNullPtr(E);
case PT_FnPtr:
@@ -1883,9 +1877,6 @@ bool ByteCodeExprGen<Emitter>::emitConst(T Value, PrimType Ty, const Expr *E) {
return this->emitConstSint64(Value, E);
case PT_Uint64:
return this->emitConstUint64(Value, E);
- case PT_IntAP:
- case PT_IntAPS:
- assert(false);
case PT_Bool:
return this->emitConstBool(Value, E);
case PT_Ptr:
diff --git a/clang/lib/AST/Interp/Context.cpp b/clang/lib/AST/Interp/Context.cpp
index 04710cd0f2c28ee..e84c0f6aae7ee93 100644
--- a/clang/lib/AST/Interp/Context.cpp
+++ b/clang/lib/AST/Interp/Context.cpp
@@ -103,7 +103,7 @@ std::optional<PrimType> Context::classify(QualType T) const {
case 8:
return PT_Sint8;
default:
- return PT_IntAPS;
+ return std::nullopt;
}
}
@@ -118,7 +118,7 @@ std::optional<PrimType> Context::classify(QualType T) const {
case 8:
return PT_Uint8;
default:
- return PT_IntAP;
+ return std::nullopt;
}
}
diff --git a/clang/lib/AST/Interp/Descriptor.cpp b/clang/lib/AST/Interp/Descriptor.cpp
index 4ecb7466998e705..db49a569eff33ea 100644
--- a/clang/lib/AST/Interp/Descriptor.cpp
+++ b/clang/lib/AST/Interp/Descriptor.cpp
@@ -10,7 +10,6 @@
#include "Boolean.h"
#include "Floating.h"
#include "FunctionPointer.h"
-#include "IntegralAP.h"
#include "Pointer.h"
#include "PrimType.h"
#include "Record.h"
@@ -183,10 +182,6 @@ static BlockCtorFn getCtorPrim(PrimType Type) {
// constructor called.
if (Type == PT_Float)
return ctorTy<PrimConv<PT_Float>::T>;
- if (Type == PT_IntAP)
- return ctorTy<PrimConv<PT_IntAP>::T>;
- if (Type == PT_IntAPS)
- return ctorTy<PrimConv<PT_IntAPS>::T>;
COMPOSITE_TYPE_SWITCH(Type, return ctorTy<T>, return nullptr);
}
@@ -196,10 +191,6 @@ static BlockDtorFn getDtorPrim(PrimType Type) {
// destructor called, since they might allocate memory.
if (Type == PT_Float)
return dtorTy<PrimConv<PT_Float>::T>;
- if (Type == PT_IntAP)
- return dtorTy<PrimConv<PT_IntAP>::T>;
- if (Type == PT_IntAPS)
- return dtorTy<PrimConv<PT_IntAPS>::T>;
COMPOSITE_TYPE_SWITCH(Type, return dtorTy<T>, return nullptr);
}
diff --git a/clang/lib/AST/Interp/EvalEmitter.cpp b/clang/lib/AST/Interp/EvalEmitter.cpp
index f46ef1067cf52a0..bdf800c60f1723f 100644
--- a/clang/lib/AST/Interp/EvalEmitter.cpp
+++ b/clang/lib/AST/Interp/EvalEmitter.cpp
@@ -9,7 +9,6 @@
#include "EvalEmitter.h"
#include "ByteCodeGenError.h"
#include "Context.h"
-#include "IntegralAP.h"
#include "Interp.h"
#include "Opcode.h"
#include "clang/AST/DeclCXX.h"
diff --git a/clang/lib/AST/Interp/Integral.h b/clang/lib/AST/Interp/Integral.h
index 4dbe9c9bcb14b43..0295a9c3b5c898c 100644
--- a/clang/lib/AST/Interp/Integral.h
+++ b/clang/lib/AST/Interp/Integral.h
@@ -29,8 +29,6 @@ namespace interp {
using APInt = llvm::APInt;
using APSInt = llvm::APSInt;
-template <bool Signed> class IntegralAP;
-
// Helper structure to select the representation.
template <unsigned Bits, bool Signed> struct Repr;
template <> struct Repr<8, false> { using Type = uint8_t; };
@@ -63,8 +61,6 @@ template <unsigned Bits, bool Signed> class Integral final {
template <typename T> explicit Integral(T V) : V(V) {}
public:
- using AsUnsigned = Integral<Bits, false>;
-
/// Zero-initializes an integral.
Integral() : V(0) {}
diff --git a/clang/lib/AST/Interp/IntegralAP.h b/clang/lib/AST/Interp/IntegralAP.h
deleted file mode 100644
index a3a8dfda020960a..000000000000000
--- a/clang/lib/AST/Interp/IntegralAP.h
+++ /dev/null
@@ -1,256 +0,0 @@
-//===--- Integral.h - Wrapper for numeric types for the VM ------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Defines the VM types and helpers operating on types.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_AST_INTERP_INTEGRAL_AP_H
-#define LLVM_CLANG_AST_INTERP_INTEGRAL_AP_H
-
-#include "clang/AST/APValue.h"
-#include "clang/AST/ComparisonCategories.h"
-#include "llvm/ADT/APSInt.h"
-#include "llvm/Support/MathExtras.h"
-#include "llvm/Support/raw_ostream.h"
-#include <cstddef>
-#include <cstdint>
-
-#include "Primitives.h"
-
-namespace clang {
-namespace interp {
-
-using APInt = llvm::APInt;
-using APSInt = llvm::APSInt;
-template <unsigned Bits, bool Signed> class Integral;
-class Boolean;
-
-template <bool Signed> class IntegralAP final {
-public:
- APSInt V;
-
-public:
- using AsUnsigned = IntegralAP<false>;
-
- template <typename T>
- IntegralAP(T Value) : V(APInt(sizeof(T) * 8, Value, std::is_signed_v<T>)) {}
-
- IntegralAP(APInt V) : V(V) {}
- IntegralAP(APSInt V) : V(V) {}
- /// Arbitrary value for initialized variables.
- IntegralAP() : V(APSInt::getMaxValue(1024, Signed)) {}
-
- IntegralAP operator-() const { return IntegralAP(-V); }
- bool operator>(IntegralAP RHS) const { return V > RHS.V; }
- bool operator>=(IntegralAP RHS) const { return V >= RHS.V; }
- bool operator<(IntegralAP RHS) const { return V < RHS.V; }
- bool operator<=(IntegralAP RHS) const { return V <= RHS.V; }
-
- explicit operator bool() const { return !V.isZero(); }
- explicit operator int8_t() const { return V.getSExtValue(); }
- explicit operator uint8_t() const { return V.getZExtValue(); }
- explicit operator int16_t() const { return V.getSExtValue(); }
- explicit operator uint16_t() const { return V.getZExtValue(); }
- explicit operator int32_t() const { return V.getSExtValue(); }
- explicit operator uint32_t() const { return V.getZExtValue(); }
- explicit operator int64_t() const { return V.getSExtValue(); }
- explicit operator uint64_t() const { return V.getZExtValue(); }
-
- template <typename T> static IntegralAP from(T Value, unsigned NumBits = 0) {
- assert(NumBits > 0);
- APSInt Copy = APSInt(APInt(NumBits, Value, Signed), !Signed);
-
- return IntegralAP<Signed>(Copy);
- }
-
- template <bool InputSigned>
- static IntegralAP from(IntegralAP<InputSigned> V, unsigned NumBits = 0) {
- if constexpr (Signed == InputSigned)
- return V;
-
- APSInt Copy = V.V;
- Copy.setIsSigned(Signed);
-
- return IntegralAP<Signed>(Copy);
- }
-
- template <unsigned Bits, bool InputSigned>
- static IntegralAP from(Integral<Bits, InputSigned> I) {
- // FIXME: Take bits parameter.
- APSInt Copy =
- APSInt(APInt(128, static_cast<int64_t>(I), InputSigned), !Signed);
- Copy.setIsSigned(Signed);
-
- assert(Copy.isSigned() == Signed);
- return IntegralAP<Signed>(Copy);
- }
- static IntegralAP from(const Boolean &B) {
- assert(false);
- return IntegralAP::zero();
- }
-
- static IntegralAP zero() {
- assert(false);
- return IntegralAP(0);
- }
-
- // FIXME: This can't be static if the bitwidth depends on V.
- static constexpr unsigned bitWidth() { return 128; }
-
- APSInt toAPSInt(unsigned Bits = 0) const { return V; }
- APValue toAPValue() const { return APValue(V); }
-
- bool isZero() const { return V.isZero(); }
- bool isPositive() const { return V.isNonNegative(); }
- bool isNegative() const { return !V.isNonNegative(); }
- bool isMin() const { return V.isMinValue(); }
- bool isMax() const { return V.isMaxValue(); }
- static bool isSigned() { return Signed; }
- bool isMinusOne() const { return Signed && V == -1; }
-
- unsigned countLeadingZeros() const { return V.countl_zero(); }
-
- void print(llvm::raw_ostream &OS) const { OS << V; }
-
- IntegralAP truncate(unsigned bitWidth) const {
- assert(false);
- return V;
- }
-
- IntegralAP<false> toUnsigned() const {
- APSInt Copy = V;
- Copy.setIsSigned(false);
- return IntegralAP<false>(Copy);
- }
-
- ComparisonCategoryResult compare(const IntegralAP &RHS) const {
- return Compare(V, RHS.V);
- }
-
- static bool increment(IntegralAP A, IntegralAP *R) {
- assert(false);
- *R = IntegralAP(A.V + 1);
- return false;
- }
-
- static bool decrement(IntegralAP A, IntegralAP *R) {
- assert(false);
- *R = IntegralAP(A.V - 1);
- return false;
- }
-
- static bool add(IntegralAP A, IntegralAP B, unsigned OpBits, IntegralAP *R) {
- return CheckAddUB(A, B, OpBits, R);
- }
-
- static bool sub(IntegralAP A, IntegralAP B, unsigned OpBits, IntegralAP *R) {
- /// FIXME: Gotta check if the result fits into OpBits bits.
- return CheckSubUB(A, B, R);
- }
-
- static bool mul(IntegralAP A, IntegralAP B, unsigned OpBits, IntegralAP *R) {
- assert(false);
- // return CheckMulUB(A.V, B.V, R->V);
- return false;
- }
-
- static bool rem(IntegralAP A, IntegralAP B, unsigned OpBits, IntegralAP *R) {
- assert(false);
- *R = IntegralAP(A.V % B.V);
- return false;
- }
-
- static bool div(IntegralAP A, IntegralAP B, unsigned OpBits, IntegralAP *R) {
- assert(false);
- *R = IntegralAP(A.V / B.V);
- return false;
- }
-
- static bool bitAnd(IntegralAP A, IntegralAP B, unsigned OpBits,
- IntegralAP *R) {
- assert(false);
- *R = IntegralAP(A.V & B.V);
- return false;
- }
-
- static bool bitOr(IntegralAP A, IntegralAP B, unsigned OpBits,
- IntegralAP *R) {
- assert(false);
- *R = IntegralAP(A.V | B.V);
- return false;
- }
-
- static bool bitXor(IntegralAP A, IntegralAP B, unsigned OpBits,
- IntegralAP *R) {
- assert(false);
- *R = IntegralAP(A.V ^ B.V);
- return false;
- }
-
- static bool neg(const IntegralAP &A, IntegralAP *R) {
- APSInt AI = A.V;
-
- AI.setIsSigned(Signed);
- *R = IntegralAP(AI);
- return false;
- }
-
- static bool comp(IntegralAP A, IntegralAP *R) {
- assert(false);
- *R = IntegralAP(~A.V);
- return false;
- }
-
- static void shiftLeft(const IntegralAP A, const IntegralAP B, unsigned OpBits,
- IntegralAP *R) {
- *R = IntegralAP(A.V << B.V.getZExtValue());
- }
-
- static void shiftRight(const IntegralAP A, const IntegralAP B,
- unsigned OpBits, IntegralAP *R) {
- *R = IntegralAP(A.V >> B.V.getZExtValue());
- }
-
-private:
- static bool CheckAddUB(const IntegralAP &A, const IntegralAP &B,
- unsigned BitWidth, IntegralAP *R) {
- if (!A.isSigned()) {
- R->V = A.V + B.V;
- return false;
- }
-
- const APSInt &LHS = A.V;
- const APSInt &RHS = B.V;
-
- APSInt Value(LHS.extend(BitWidth) + RHS.extend(BitWidth), false);
- APSInt Result = Value.trunc(LHS.getBitWidth());
- if (Result.extend(BitWidth) != Value)
- return true;
-
- R->V = Result;
- return false;
- }
- static bool CheckSubUB(const IntegralAP &A, const IntegralAP &B,
- IntegralAP *R) {
- R->V = A.V - B.V;
- return false; // Success!
- }
-};
-
-template <bool Signed>
-inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
- IntegralAP<Signed> I) {
- I.print(OS);
- return OS;
-}
-
-} // namespace interp
-} // namespace clang
-
-#endif
diff --git a/clang/lib/AST/Interp/Interp.h b/clang/lib/AST/Interp/Interp.h
index 9d5ec3315415cf7..dd37150b63f6db0 100644
--- a/clang/lib/AST/Interp/Interp.h
+++ b/clang/lib/AST/Interp/Interp.h
@@ -294,11 +294,7 @@ bool AddSubMulHelper(InterpState &S, CodePtr OpPC, unsigned Bits, const T &LHS,
return true;
} else {
S.CCEDiag(E, diag::note_constexpr_overflow) << Value << Type;
- if (!S.noteUndefinedBehavior()) {
- S.Stk.pop<T>();
- return false;
- }
- return true;
+ return S.noteUndefinedBehavior();
}
}
@@ -1583,7 +1579,7 @@ bool CastFloatingIntegral(InterpState &S, CodePtr OpPC) {
S.Stk.push<T>(T(F.isNonZero()));
return true;
} else {
- APSInt Result(std::max(8u, T::bitWidth()),
+ APSInt Result(std::max(8u, T::bitWidth() + 1),
/*IsUnsigned=*/!T::isSigned());
auto Status = F.convertToInteger(Result);
@@ -1669,11 +1665,9 @@ inline bool Shr(InterpState &S, CodePtr OpPC) {
if (!CheckShift(S, OpPC, LHS, RHS, Bits))
return false;
- typename LT::AsUnsigned R;
- LT::AsUnsigned::shiftRight(LT::AsUnsigned::from(LHS),
- LT::AsUnsigned::from(RHS), Bits, &R);
- S.Stk.push<LT>(LT::from(R));
-
+ Integral<LT::bitWidth(), false> R;
+ Integral<LT::bitWidth(), false>::shiftRight(LHS.toUnsigned(), RHS, Bits, &R);
+ S.Stk.push<LT>(R);
return true;
}
@@ -1688,10 +1682,9 @@ inline bool Shl(InterpState &S, CodePtr OpPC) {
if (!CheckShift(S, OpPC, LHS, RHS, Bits))
return false;
- typename LT::AsUnsigned R;
- LT::AsUnsigned::shiftLeft(LT::AsUnsigned::from(LHS),
- LT::AsUnsigned::from(RHS), Bits, &R);
- S.Stk.push<LT>(LT::from(R));
+ Integral<LT::bitWidth(), false> R;
+ Integral<LT::bitWidth(), false>::shiftLeft(LHS.toUnsigned(), RHS, Bits, &R);
+ S.Stk.push<LT>(R);
return true;
}
diff --git a/clang/lib/AST/Interp/InterpStack.h b/clang/lib/AST/Interp/InterpStack.h
index 3fd0f63c781fc70..ab4351a6dc679fd 100644
--- a/clang/lib/AST/Interp/InterpStack.h
+++ b/clang/lib/AST/Interp/InterpStack.h
@@ -14,7 +14,6 @@
#define LLVM_CLANG_AST_INTERP_INTERPSTACK_H
#include "FunctionPointer.h"
-#include "IntegralAP.h"
#include "PrimType.h"
#include <memory>
#include <vector>
@@ -184,10 +183,6 @@ class InterpStack final {
return PT_Float;
else if constexpr (std::is_same_v<T, FunctionPointer>)
return PT_FnPtr;
- else if constexpr (std::is_same_v<T, IntegralAP<true>>)
- return PT_IntAP;
- else if constexpr (std::is_same_v<T, IntegralAP<false>>)
- return PT_IntAP;
llvm_unreachable("unknown type push()'ed into InterpStack");
}
diff --git a/clang/lib/AST/Interp/Opcodes.td b/clang/lib/AST/Interp/Opcodes.td
index 9fc4938bb37bde8..0ce64b769b01fb7 100644
--- a/clang/lib/AST/Interp/Opcodes.td
+++ b/clang/lib/AST/Interp/Opcodes.td
@@ -25,8 +25,6 @@ def Sint32 : Type;
def Uint32 : Type;
def Sint64 : Type;
def Uint64 : Type;
-def IntAP : Type;
-def IntAPS : Type;
def Float : Type;
def Ptr : Type;
def FnPtr : Type;
@@ -69,7 +67,7 @@ class TypeClass {
def IntegerTypeClass : TypeClass {
let Types = [Sint8, Uint8, Sint16, Uint16, Sint32,
- Uint32, Sint64, Uint64, IntAP, IntAPS];
+ Uint32, Sint64, Uint64];
}
def NumberTypeClass : TypeClass {
@@ -556,11 +554,11 @@ def Comp: Opcode {
//===----------------------------------------------------------------------===//
def FromCastTypeClass : TypeClass {
- let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, Bool, IntAP, IntAPS];
+ let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, Bool];
}
def ToCastTypeClass : TypeClass {
- let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, Bool, IntAP, IntAPS];
+ let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, Bool];
}
def Cast: Opcode {
diff --git a/clang/lib/AST/Interp/PrimType.cpp b/clang/lib/AST/Interp/PrimType.cpp
index 9b96dcfe6a272fc..a9b5d8ea8cc8c7c 100644
--- a/clang/lib/AST/Interp/PrimType.cpp
+++ b/clang/lib/AST/Interp/PrimType.cpp
@@ -10,7 +10,6 @@
#include "Boolean.h"
#include "Floating.h"
#include "FunctionPointer.h"
-#include "IntegralAP.h"
#include "Pointer.h"
using namespace clang;
diff --git a/clang/lib/AST/Interp/PrimType.h b/clang/lib/AST/Interp/PrimType.h
index 8c5e87f37be1867..7c7ee6120b89a4a 100644
--- a/clang/lib/AST/Interp/PrimType.h
+++ b/clang/lib/AST/Interp/PrimType.h
@@ -25,7 +25,6 @@ class Pointer;
class Boolean;
class Floating;
class FunctionPointer;
-template <bool Signed> class IntegralAP;
template <unsigned Bits, bool Signed> class Integral;
/// Enumeration of the primitive types of the VM.
@@ -38,8 +37,6 @@ enum PrimType : unsigned {
PT_Uint32,
PT_Sint64,
PT_Uint64,
- PT_IntAP,
- PT_IntAPS,
PT_Bool,
PT_Float,
PT_Ptr,
@@ -71,12 +68,6 @@ template <> struct PrimConv<PT_Sint32> { using T = Integral<32, true>; };
template <> struct PrimConv<PT_Uint32> { using T = Integral<32, false>; };
template <> struct PrimConv<PT_Sint64> { using T = Integral<64, true>; };
template <> struct PrimConv<PT_Uint64> { using T = Integral<64, false>; };
-template <> struct PrimConv<PT_IntAP> {
- using T = IntegralAP<false>;
-};
-template <> struct PrimConv<PT_IntAPS> {
- using T = IntegralAP<true>;
-};
template <> struct PrimConv<PT_Float> { using T = Floating; };
template <> struct PrimConv<PT_Bool> { using T = Boolean; };
template <> struct PrimConv<PT_Ptr> { using T = Pointer; };
@@ -117,8 +108,6 @@ static inline bool aligned(const void *P) {
TYPE_SWITCH_CASE(PT_Uint32, B) \
TYPE_SWITCH_CASE(PT_Sint64, B) \
TYPE_SWITCH_CASE(PT_Uint64, B) \
- TYPE_SWITCH_CASE(PT_IntAP, B) \
- TYPE_SWITCH_CASE(PT_IntAPS, B) \
TYPE_SWITCH_CASE(PT_Float, B) \
TYPE_SWITCH_CASE(PT_Bool, B) \
TYPE_SWITCH_CASE(PT_Ptr, B) \
@@ -137,8 +126,6 @@ static inline bool aligned(const void *P) {
TYPE_SWITCH_CASE(PT_Uint32, B) \
TYPE_SWITCH_CASE(PT_Sint64, B) \
TYPE_SWITCH_CASE(PT_Uint64, B) \
- TYPE_SWITCH_CASE(PT_IntAP, B) \
- TYPE_SWITCH_CASE(PT_IntAPS, B) \
TYPE_SWITCH_CASE(PT_Bool, B) \
default: \
llvm_unreachable("Not an integer value"); \
diff --git a/clang/test/AST/Interp/literals.cpp b/clang/test/AST/Interp/literals.cpp
index 0dd036353fa7efd..ceda59405ea9105 100644
--- a/clang/test/AST/Interp/literals.cpp
+++ b/clang/test/AST/Interp/literals.cpp
@@ -7,8 +7,6 @@
#define INT_MAX __INT_MAX__
typedef __INTPTR_TYPE__ intptr_t;
-typedef __int128 int128_t;
-typedef unsigned __int128 uint128_t;
static_assert(true, "");
@@ -28,66 +26,6 @@ static_assert(number != 10, ""); // expected-error{{failed}} \
// expected-note{{evaluates to}} \
// ref-note{{evaluates to}}
-
-namespace i128 {
- constexpr int128_t I128_1 = 12;
- static_assert(I128_1 == 12, "");
- static_assert(I128_1 != 10, "");
- static_assert(I128_1 != 12, ""); // expected-error{{failed}} \
- // ref-error{{failed}} \
- // expected-note{{evaluates to}} \
- // ref-note{{evaluates to}}
-
- static const __uint128_t UINT128_MAX =__uint128_t(__int128_t(-1L));
- static_assert(UINT128_MAX == -1, "");
-
- static const __int128_t INT128_MAX = UINT128_MAX >> (__int128_t)1;
- static_assert(INT128_MAX != 0, "");
- static const __int128_t INT128_MIN = -INT128_MAX - 1;
- constexpr __int128 A = INT128_MAX + 1; // expected-error {{must be initialized by a constant expression}} \
- // expected-note {{outside the range}} \
- // ref-error {{must be initialized by a constant expression}} \
- // ref-note {{outside the range}}
- constexpr int128_t Two = (int128_t)1 << 1ul;
- static_assert(Two == 2, "");
-
-#if __cplusplus >= 201402L
- template <typename T>
- constexpr T CastFrom(__int128_t A) {
- T B = (T)A;
- return B;
- }
- static_assert(CastFrom<char>(12) == 12, "");
- static_assert(CastFrom<unsigned char>(12) == 12, "");
- static_assert(CastFrom<long>(12) == 12, "");
- static_assert(CastFrom<unsigned short>(12) == 12, "");
- static_assert(CastFrom<int128_t>(12) == 12, "");
- static_assert(CastFrom<float>(12) == 12, "");
- static_assert(CastFrom<double>(12) == 12, "");
- static_assert(CastFrom<long double>(12) == 12, "");
-
- template <typename T>
- constexpr __int128 CastTo(T A) {
- int128_t B = (int128_t)A;
- return B;
- }
- static_assert(CastTo<char>(12) == 12, "");
- static_assert(CastTo<unsigned char>(12) == 12, "");
- static_assert(CastTo<long>(12) == 12, "");
- static_assert(CastTo<unsigned long long>(12) == 12, "");
- static_assert(CastTo<float>(12) == 12, "");
- static_assert(CastTo<double>(12) == 12, "");
- static_assert(CastTo<long double>(12) == 12, "");
-#endif
-
-constexpr int128_t Error = __LDBL_MAX__; // ref-warning {{implicit conversion of out of range value}} \
- // ref-error {{must be initialized by a constant expression}} \
- // ref-note {{is outside the range of representable values of type}} \
- // expected-warning {{implicit conversion of out of range value}} \
- // expected-error {{must be initialized by a constant expression}} \
- // expected-note {{is outside the range of representable values of type}}
-}
-
constexpr bool b = number;
static_assert(b, "");
constexpr int one = true;
More information about the cfe-commits
mailing list