mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2024-12-28 10:46:11 +00:00
[Analysis] Support aggregate access types in TBAA
This patch implements analysis for new-format TBAA access tags with aggregate types as their final access types. Differential Revision: https://reviews.llvm.org/D41501 llvm-svn: 324092
This commit is contained in:
Ivan A. Kosarev
parent
42983551bd
commit
ab68bbe515
@ -104,21 +104,6 @@
|
||||
// If neither node is an ancestor of the other and they have the same root,
|
||||
// then we say NoAlias.
|
||||
//
|
||||
// TODO: The current metadata format doesn't support struct
|
||||
// fields. For example:
|
||||
// struct X {
|
||||
// double d;
|
||||
// int i;
|
||||
// };
|
||||
// void foo(struct X *x, struct X *y, double *p) {
|
||||
// *x = *y;
|
||||
// *p = 0.0;
|
||||
// }
|
||||
// Struct X has a double member, so the store to *x can alias the store to *p.
|
||||
// Currently it's not possible to precisely describe all the things struct X
|
||||
// aliases, so struct assignments must use conservative TBAA nodes. There's
|
||||
// no scheme for attaching metadata to @llvm.memcpy yet either.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
|
||||
@ -146,6 +131,17 @@ static cl::opt<bool> EnableTBAA("enable-tbaa", cl::init(true), cl::Hidden);
|
||||
|
||||
namespace {
|
||||
|
||||
/// isNewFormatTypeNode - Return true iff the given type node is in the new
|
||||
/// size-aware format.
|
||||
static bool isNewFormatTypeNode(const MDNode *N) {
|
||||
if (N->getNumOperands() < 3)
|
||||
return false;
|
||||
// In the old format the first operand is a string.
|
||||
if (!isa<MDNode>(N->getOperand(0)))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/// This is a simple wrapper around an MDNode which provides a higher-level
|
||||
/// interface by hiding the details of how alias analysis information is encoded
|
||||
/// in its operands.
|
||||
@ -160,8 +156,15 @@ public:
|
||||
/// getNode - Get the MDNode for this TBAANode.
|
||||
MDNodeTy *getNode() const { return Node; }
|
||||
|
||||
/// isNewFormat - Return true iff the wrapped type node is in the new
|
||||
/// size-aware format.
|
||||
bool isNewFormat() const { return isNewFormatTypeNode(Node); }
|
||||
|
||||
/// getParent - Get this TBAANode's Alias tree parent.
|
||||
TBAANodeImpl<MDNodeTy> getParent() const {
|
||||
if (isNewFormat())
|
||||
return TBAANodeImpl(cast<MDNodeTy>(Node->getOperand(0)));
|
||||
|
||||
if (Node->getNumOperands() < 2)
|
||||
return TBAANodeImpl<MDNodeTy>();
|
||||
MDNodeTy *P = dyn_cast_or_null<MDNodeTy>(Node->getOperand(1));
|
||||
@ -196,7 +199,7 @@ using MutableTBAANode = TBAANodeImpl<MDNode>;
|
||||
/// information is encoded in its operands.
|
||||
template<typename MDNodeTy>
|
||||
class TBAAStructTagNodeImpl {
|
||||
/// This node should be created with createTBAAStructTagNode.
|
||||
/// This node should be created with createTBAAAccessTag().
|
||||
MDNodeTy *Node;
|
||||
|
||||
public:
|
||||
@ -205,6 +208,17 @@ public:
|
||||
/// Get the MDNode for this TBAAStructTagNode.
|
||||
MDNodeTy *getNode() const { return Node; }
|
||||
|
||||
/// isNewFormat - Return true iff the wrapped access tag is in the new
|
||||
/// size-aware format.
|
||||
bool isNewFormat() const {
|
||||
if (Node->getNumOperands() < 4)
|
||||
return false;
|
||||
if (MDNodeTy *AccessType = getAccessType())
|
||||
if (!TBAANodeImpl<MDNodeTy>(AccessType).isNewFormat())
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
MDNodeTy *getBaseType() const {
|
||||
return dyn_cast_or_null<MDNode>(Node->getOperand(0));
|
||||
}
|
||||
@ -217,13 +231,20 @@ public:
|
||||
return mdconst::extract<ConstantInt>(Node->getOperand(2))->getZExtValue();
|
||||
}
|
||||
|
||||
uint64_t getSize() const {
|
||||
if (!isNewFormat())
|
||||
return UINT64_MAX;
|
||||
return mdconst::extract<ConstantInt>(Node->getOperand(3))->getZExtValue();
|
||||
}
|
||||
|
||||
/// Test if this TBAAStructTagNode represents a type for objects
|
||||
/// which are not modified (by any means) in the context where this
|
||||
/// AliasAnalysis is relevant.
|
||||
bool isTypeImmutable() const {
|
||||
if (Node->getNumOperands() < 4)
|
||||
unsigned OpNo = isNewFormat() ? 4 : 3;
|
||||
if (Node->getNumOperands() < OpNo + 1)
|
||||
return false;
|
||||
ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(3));
|
||||
ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(OpNo));
|
||||
if (!CI)
|
||||
return false;
|
||||
return CI->getValue()[0];
|
||||
@ -241,7 +262,7 @@ using MutableTBAAStructTagNode = TBAAStructTagNodeImpl<MDNode>;
|
||||
/// higher-level interface by hiding the details of how alias analysis
|
||||
/// information is encoded in its operands.
|
||||
class TBAAStructTypeNode {
|
||||
/// This node should be created with createTBAAStructTypeNode.
|
||||
/// This node should be created with createTBAATypeNode().
|
||||
const MDNode *Node = nullptr;
|
||||
|
||||
public:
|
||||
@ -251,43 +272,80 @@ public:
|
||||
/// Get the MDNode for this TBAAStructTypeNode.
|
||||
const MDNode *getNode() const { return Node; }
|
||||
|
||||
/// isNewFormat - Return true iff the wrapped type node is in the new
|
||||
/// size-aware format.
|
||||
bool isNewFormat() const { return isNewFormatTypeNode(Node); }
|
||||
|
||||
bool operator==(const TBAAStructTypeNode &Other) const {
|
||||
return getNode() == Other.getNode();
|
||||
}
|
||||
|
||||
/// getId - Return type identifier.
|
||||
Metadata *getId() const {
|
||||
return Node->getOperand(isNewFormat() ? 2 : 0);
|
||||
}
|
||||
|
||||
unsigned getNumFields() const {
|
||||
unsigned FirstFieldOpNo = isNewFormat() ? 3 : 1;
|
||||
unsigned NumOpsPerField = isNewFormat() ? 3 : 2;
|
||||
return (getNode()->getNumOperands() - FirstFieldOpNo) / NumOpsPerField;
|
||||
}
|
||||
|
||||
TBAAStructTypeNode getFieldType(unsigned FieldIndex) const {
|
||||
unsigned FirstFieldOpNo = isNewFormat() ? 3 : 1;
|
||||
unsigned NumOpsPerField = isNewFormat() ? 3 : 2;
|
||||
unsigned OpIndex = FirstFieldOpNo + FieldIndex * NumOpsPerField;
|
||||
auto *TypeNode = cast<MDNode>(getNode()->getOperand(OpIndex));
|
||||
return TBAAStructTypeNode(TypeNode);
|
||||
}
|
||||
|
||||
/// Get this TBAAStructTypeNode's field in the type DAG with
|
||||
/// given offset. Update the offset to be relative to the field type.
|
||||
TBAAStructTypeNode getParent(uint64_t &Offset) const {
|
||||
// Parent can be omitted for the root node.
|
||||
if (Node->getNumOperands() < 2)
|
||||
return TBAAStructTypeNode();
|
||||
|
||||
// Fast path for a scalar type node and a struct type node with a single
|
||||
// field.
|
||||
if (Node->getNumOperands() <= 3) {
|
||||
uint64_t Cur = Node->getNumOperands() == 2
|
||||
? 0
|
||||
: mdconst::extract<ConstantInt>(Node->getOperand(2))
|
||||
->getZExtValue();
|
||||
Offset -= Cur;
|
||||
MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(1));
|
||||
if (!P)
|
||||
TBAAStructTypeNode getField(uint64_t &Offset) const {
|
||||
bool NewFormat = isNewFormat();
|
||||
if (NewFormat) {
|
||||
// New-format root and scalar type nodes have no fields.
|
||||
if (Node->getNumOperands() < 6)
|
||||
return TBAAStructTypeNode();
|
||||
return TBAAStructTypeNode(P);
|
||||
} else {
|
||||
// Parent can be omitted for the root node.
|
||||
if (Node->getNumOperands() < 2)
|
||||
return TBAAStructTypeNode();
|
||||
|
||||
// Fast path for a scalar type node and a struct type node with a single
|
||||
// field.
|
||||
if (Node->getNumOperands() <= 3) {
|
||||
uint64_t Cur = Node->getNumOperands() == 2
|
||||
? 0
|
||||
: mdconst::extract<ConstantInt>(Node->getOperand(2))
|
||||
->getZExtValue();
|
||||
Offset -= Cur;
|
||||
MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(1));
|
||||
if (!P)
|
||||
return TBAAStructTypeNode();
|
||||
return TBAAStructTypeNode(P);
|
||||
}
|
||||
}
|
||||
|
||||
// Assume the offsets are in order. We return the previous field if
|
||||
// the current offset is bigger than the given offset.
|
||||
unsigned FirstFieldOpNo = NewFormat ? 3 : 1;
|
||||
unsigned NumOpsPerField = NewFormat ? 3 : 2;
|
||||
unsigned TheIdx = 0;
|
||||
for (unsigned Idx = 1; Idx < Node->getNumOperands(); Idx += 2) {
|
||||
for (unsigned Idx = FirstFieldOpNo; Idx < Node->getNumOperands();
|
||||
Idx += NumOpsPerField) {
|
||||
uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(Idx + 1))
|
||||
->getZExtValue();
|
||||
if (Cur > Offset) {
|
||||
assert(Idx >= 3 &&
|
||||
"TBAAStructTypeNode::getParent should have an offset match!");
|
||||
TheIdx = Idx - 2;
|
||||
assert(Idx >= FirstFieldOpNo + NumOpsPerField &&
|
||||
"TBAAStructTypeNode::getField should have an offset match!");
|
||||
TheIdx = Idx - NumOpsPerField;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Move along the last field.
|
||||
if (TheIdx == 0)
|
||||
TheIdx = Node->getNumOperands() - 2;
|
||||
TheIdx = Node->getNumOperands() - NumOpsPerField;
|
||||
uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(TheIdx + 1))
|
||||
->getZExtValue();
|
||||
Offset -= Cur;
|
||||
@ -403,15 +461,11 @@ bool MDNode::isTBAAVtableAccess() const {
|
||||
}
|
||||
|
||||
// For struct-path aware TBAA, we use the access type of the tag.
|
||||
if (getNumOperands() < 2)
|
||||
return false;
|
||||
MDNode *Tag = cast_or_null<MDNode>(getOperand(1));
|
||||
if (!Tag)
|
||||
return false;
|
||||
if (MDString *Tag1 = dyn_cast<MDString>(Tag->getOperand(0))) {
|
||||
if (Tag1->getString() == "vtable pointer")
|
||||
TBAAStructTagNode Tag(this);
|
||||
TBAAStructTypeNode AccessType(Tag.getAccessType());
|
||||
if(auto *Id = dyn_cast<MDString>(AccessType.getId()))
|
||||
if (Id->getString() == "vtable pointer")
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -485,26 +539,6 @@ void Instruction::getAAMetadata(AAMDNodes &N, bool Merge) const {
|
||||
N.NoAlias = getMetadata(LLVMContext::MD_noalias);
|
||||
}
|
||||
|
||||
static bool findAccessType(TBAAStructTagNode BaseTag,
|
||||
const MDNode *AccessTypeNode,
|
||||
uint64_t &OffsetInBase) {
|
||||
// Start from the base type, follow the edge with the correct offset in
|
||||
// the type DAG and adjust the offset until we reach the access type or
|
||||
// until we reach a root node.
|
||||
TBAAStructTypeNode BaseType(BaseTag.getBaseType());
|
||||
OffsetInBase = BaseTag.getOffset();
|
||||
|
||||
while (const MDNode *BaseTypeNode = BaseType.getNode()) {
|
||||
if (BaseTypeNode == AccessTypeNode)
|
||||
return true;
|
||||
|
||||
// Follow the edge with the correct offset, Offset will be adjusted to
|
||||
// be relative to the field type.
|
||||
BaseType = BaseType.getParent(OffsetInBase);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static const MDNode *createAccessTag(const MDNode *AccessType) {
|
||||
// If there is no access type or the access type is the root node, then
|
||||
// we don't have any useful access tag to return.
|
||||
@ -512,12 +546,111 @@ static const MDNode *createAccessTag(const MDNode *AccessType) {
|
||||
return nullptr;
|
||||
|
||||
Type *Int64 = IntegerType::get(AccessType->getContext(), 64);
|
||||
auto *ImmutabilityFlag = ConstantAsMetadata::get(ConstantInt::get(Int64, 0));
|
||||
auto *OffsetNode = ConstantAsMetadata::get(ConstantInt::get(Int64, 0));
|
||||
|
||||
if (TBAAStructTypeNode(AccessType).isNewFormat()) {
|
||||
// TODO: Take access ranges into account when matching access tags and
|
||||
// fix this code to generate actual access sizes for generic tags.
|
||||
uint64_t AccessSize = UINT64_MAX;
|
||||
auto *SizeNode =
|
||||
ConstantAsMetadata::get(ConstantInt::get(Int64, AccessSize));
|
||||
Metadata *Ops[] = {const_cast<MDNode*>(AccessType),
|
||||
const_cast<MDNode*>(AccessType),
|
||||
OffsetNode, SizeNode};
|
||||
return MDNode::get(AccessType->getContext(), Ops);
|
||||
}
|
||||
|
||||
Metadata *Ops[] = {const_cast<MDNode*>(AccessType),
|
||||
const_cast<MDNode*>(AccessType), ImmutabilityFlag};
|
||||
const_cast<MDNode*>(AccessType),
|
||||
OffsetNode};
|
||||
return MDNode::get(AccessType->getContext(), Ops);
|
||||
}
|
||||
|
||||
static bool hasField(TBAAStructTypeNode BaseType,
|
||||
TBAAStructTypeNode FieldType) {
|
||||
for (unsigned I = 0, E = BaseType.getNumFields(); I != E; ++I) {
|
||||
TBAAStructTypeNode T = BaseType.getFieldType(I);
|
||||
if (T == FieldType || hasField(T, FieldType))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/// Return true if for two given accesses, one of the accessed objects may be a
|
||||
/// subobject of the other. The \p BaseTag and \p SubobjectTag parameters
|
||||
/// describe the accesses to the base object and the subobject respectively.
|
||||
/// \p CommonType must be the metadata node describing the common type of the
|
||||
/// accessed objects. On return, \p MayAlias is set to true iff these accesses
|
||||
/// may alias and \p Generic, if not null, points to the most generic access
|
||||
/// tag for the given two.
|
||||
static bool mayBeAccessToSubobjectOf(TBAAStructTagNode BaseTag,
|
||||
TBAAStructTagNode SubobjectTag,
|
||||
const MDNode *CommonType,
|
||||
const MDNode **GenericTag,
|
||||
bool &MayAlias) {
|
||||
// If the base object is of the least common type, then this may be an access
|
||||
// to its subobject.
|
||||
if (BaseTag.getAccessType() == BaseTag.getBaseType() &&
|
||||
BaseTag.getAccessType() == CommonType) {
|
||||
if (GenericTag)
|
||||
*GenericTag = createAccessTag(CommonType);
|
||||
MayAlias = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
// If the access to the base object is through a field of the subobject's
|
||||
// type, then this may be an access to that field. To check for that we start
|
||||
// from the base type, follow the edge with the correct offset in the type DAG
|
||||
// and adjust the offset until we reach the field type or until we reach the
|
||||
// access type.
|
||||
bool NewFormat = BaseTag.isNewFormat();
|
||||
TBAAStructTypeNode BaseType(BaseTag.getBaseType());
|
||||
uint64_t OffsetInBase = BaseTag.getOffset();
|
||||
|
||||
for (;;) {
|
||||
// In the old format there is no distinction between fields and parent
|
||||
// types, so in this case we consider all nodes up to the root.
|
||||
if (!BaseType.getNode()) {
|
||||
assert(!NewFormat && "Did not see access type in access path!");
|
||||
break;
|
||||
}
|
||||
|
||||
if (BaseType.getNode() == SubobjectTag.getBaseType()) {
|
||||
bool SameMemberAccess = OffsetInBase == SubobjectTag.getOffset();
|
||||
if (GenericTag) {
|
||||
*GenericTag = SameMemberAccess ? SubobjectTag.getNode() :
|
||||
createAccessTag(CommonType);
|
||||
}
|
||||
MayAlias = SameMemberAccess;
|
||||
return true;
|
||||
}
|
||||
|
||||
// With new-format nodes we stop at the access type.
|
||||
if (NewFormat && BaseType.getNode() == BaseTag.getAccessType())
|
||||
break;
|
||||
|
||||
// Follow the edge with the correct offset. Offset will be adjusted to
|
||||
// be relative to the field type.
|
||||
BaseType = BaseType.getField(OffsetInBase);
|
||||
}
|
||||
|
||||
// If the base object has a direct or indirect field of the subobject's type,
|
||||
// then this may be an access to that field. We need this to check now that
|
||||
// we support aggreagtes as access types.
|
||||
if (NewFormat) {
|
||||
// TBAAStructTypeNode BaseAccessType(BaseTag.getAccessType());
|
||||
TBAAStructTypeNode FieldType(SubobjectTag.getBaseType());
|
||||
if (hasField(BaseType, FieldType)) {
|
||||
if (GenericTag)
|
||||
*GenericTag = createAccessTag(CommonType);
|
||||
MayAlias = true;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/// matchTags - Return true if the given couple of accesses are allowed to
|
||||
/// overlap. If \arg GenericTag is not null, then on return it points to the
|
||||
/// most generic access descriptor for the given two.
|
||||
@ -545,38 +678,26 @@ static bool matchAccessTags(const MDNode *A, const MDNode *B,
|
||||
const MDNode *CommonType = getLeastCommonType(TagA.getAccessType(),
|
||||
TagB.getAccessType());
|
||||
|
||||
// TODO: We need to check if AccessType of TagA encloses AccessType of
|
||||
// TagB to support aggregate AccessType. If yes, return true.
|
||||
|
||||
// Climb the type DAG from base type of A to see if we reach base type of B.
|
||||
uint64_t OffsetA;
|
||||
if (findAccessType(TagA, TagB.getBaseType(), OffsetA)) {
|
||||
bool SameMemberAccess = OffsetA == TagB.getOffset();
|
||||
if (GenericTag)
|
||||
*GenericTag = SameMemberAccess ? TagB.getNode() :
|
||||
createAccessTag(CommonType);
|
||||
return SameMemberAccess;
|
||||
}
|
||||
|
||||
// Climb the type DAG from base type of B to see if we reach base type of A.
|
||||
uint64_t OffsetB;
|
||||
if (findAccessType(TagB, TagA.getBaseType(), OffsetB)) {
|
||||
bool SameMemberAccess = OffsetB == TagA.getOffset();
|
||||
if (GenericTag)
|
||||
*GenericTag = SameMemberAccess ? TagA.getNode() :
|
||||
createAccessTag(CommonType);
|
||||
return SameMemberAccess;
|
||||
}
|
||||
|
||||
if (GenericTag)
|
||||
*GenericTag = createAccessTag(CommonType);
|
||||
|
||||
// If the final access types have different roots, they're part of different
|
||||
// potentially unrelated type systems, so we must be conservative.
|
||||
if (!CommonType)
|
||||
if (!CommonType) {
|
||||
if (GenericTag)
|
||||
*GenericTag = nullptr;
|
||||
return true;
|
||||
}
|
||||
|
||||
// If they have the same root, then we've proved there's no alias.
|
||||
// If one of the accessed objects may be a subobject of the other, then such
|
||||
// accesses may alias.
|
||||
bool MayAlias;
|
||||
if (mayBeAccessToSubobjectOf(/* BaseTag= */ TagA, /* SubobjectTag= */ TagB,
|
||||
CommonType, GenericTag, MayAlias) ||
|
||||
mayBeAccessToSubobjectOf(/* BaseTag= */ TagB, /* SubobjectTag= */ TagA,
|
||||
CommonType, GenericTag, MayAlias))
|
||||
return MayAlias;
|
||||
|
||||
// Otherwise, we've proved there's no alias.
|
||||
if (GenericTag)
|
||||
*GenericTag = createAccessTag(CommonType);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
138
llvm/test/Analysis/TypeBasedAliasAnalysis/aggregates.ll
Normal file
138
llvm/test/Analysis/TypeBasedAliasAnalysis/aggregates.ll
Normal file
@ -0,0 +1,138 @@
|
||||
; RUN: opt < %s -tbaa -basicaa -aa-eval -evaluate-aa-metadata \
|
||||
; RUN: -print-no-aliases -print-may-aliases -disable-output 2>&1 | \
|
||||
; RUN: FileCheck %s
|
||||
; RUN: opt < %s -tbaa -basicaa -gvn -S | FileCheck %s --check-prefix=OPT
|
||||
;
|
||||
; Check that TBAA handles access tags with aggregate final access types
|
||||
; correctly.
|
||||
|
||||
%A = type { i32 } ; struct A { int i; };
|
||||
%B = type { %A } ; struct B { A a; };
|
||||
%C = type { %B } ; struct C { B b; };
|
||||
%D = type { i16 } ; struct D { short s; };
|
||||
|
||||
; int vs. A::i => MayAlias.
|
||||
define i32 @f1(i32* %i, %A* %a) {
|
||||
entry:
|
||||
; CHECK-LABEL: f1
|
||||
; CHECK: MayAlias: store i32 7, {{.*}} <-> store i32 5,
|
||||
; OPT-LABEL: f1
|
||||
; OPT: store i32 5,
|
||||
; OPT: store i32 7,
|
||||
; OPT: %[[RET:.*]] = load i32,
|
||||
; OPT: ret i32 %[[RET]]
|
||||
store i32 5, i32* %i, align 4, !tbaa !3 ; TAG_int
|
||||
%A_i = getelementptr inbounds %A, %A* %a, i64 0, i32 0
|
||||
store i32 7, i32* %A_i, align 4, !tbaa !5 ; TAG_A_i
|
||||
%0 = load i32, i32* %i, align 4, !tbaa !3 ; TAG_int
|
||||
ret i32 %0
|
||||
}
|
||||
|
||||
; int vs. B::a => MayAlias.
|
||||
define i32 @f2(i32* %i, %B* %b) {
|
||||
entry:
|
||||
; CHECK-LABEL: f2
|
||||
; CHECK: MayAlias: store i32 7, {{.*}} <-> store i32 5,
|
||||
; OPT-LABEL: f2
|
||||
; OPT: store i32 5,
|
||||
; OPT: store i32 7,
|
||||
; OPT: %[[RET:.*]] = load i32,
|
||||
; OPT: ret i32 %[[RET]]
|
||||
store i32 5, i32* %i, align 4, !tbaa !3 ; TAG_int
|
||||
%B_a = getelementptr inbounds %B, %B* %b, i64 0, i32 0, i32 0
|
||||
store i32 7, i32* %B_a, align 4, !tbaa !7 ; TAG_B_a
|
||||
%0 = load i32, i32* %i, align 4, !tbaa !3 ; TAG_int
|
||||
ret i32 %0
|
||||
}
|
||||
|
||||
; int vs. C::b => MayAlias.
|
||||
define i32 @f3(i32* %i, %C* %c) {
|
||||
entry:
|
||||
; CHECK-LABEL: f3
|
||||
; CHECK: MayAlias: store i32 7, {{.*}} <-> store i32 5,
|
||||
; OPT-LABEL: f3
|
||||
; OPT: store i32 5,
|
||||
; OPT: store i32 7,
|
||||
; OPT: %[[RET:.*]] = load i32,
|
||||
; OPT: ret i32 %[[RET]]
|
||||
store i32 5, i32* %i, align 4, !tbaa !3 ; TAG_int
|
||||
%C_b = getelementptr inbounds %C, %C* %c, i64 0, i32 0, i32 0, i32 0
|
||||
store i32 7, i32* %C_b, align 4, !tbaa !9 ; TAG_C_b
|
||||
%0 = load i32, i32* %i, align 4, !tbaa !3 ; TAG_int
|
||||
ret i32 %0
|
||||
}
|
||||
|
||||
; A vs. C::b => MayAlias.
|
||||
define i32 @f4(%A* %a, %C* %c) {
|
||||
entry:
|
||||
; CHECK-LABEL: f4
|
||||
; CHECK: MayAlias: store i32 7, {{.*}} <-> store i32 5,
|
||||
; OPT-LABEL: f4
|
||||
; OPT: store i32 5,
|
||||
; OPT: store i32 7,
|
||||
; OPT: %[[RET:.*]] = load i32,
|
||||
; OPT: ret i32 %[[RET]]
|
||||
%ap = getelementptr inbounds %A, %A* %a, i64 0, i32 0
|
||||
store i32 5, i32* %ap, align 4, !tbaa !10 ; TAG_A
|
||||
%C_b = getelementptr inbounds %C, %C* %c, i64 0, i32 0, i32 0, i32 0
|
||||
store i32 7, i32* %C_b, align 4, !tbaa !9 ; TAG_C_b
|
||||
%0 = load i32, i32* %ap, align 4, !tbaa !10 ; TAG_A
|
||||
ret i32 %0
|
||||
}
|
||||
|
||||
; short vs. C::b => NoAlias.
|
||||
define i32 @f5(i32* %i, %C* %c) {
|
||||
entry:
|
||||
; CHECK-LABEL: f5
|
||||
; CHECK: NoAlias: store i32 7, {{.*}} <-> store i32 5,
|
||||
; OPT-LABEL: f5
|
||||
; OPT: store i32 5,
|
||||
; OPT: store i32 7,
|
||||
; OPT: ret i32 5
|
||||
store i32 5, i32* %i, align 4, !tbaa !12 ; TAG_short
|
||||
%C_b = getelementptr inbounds %C, %C* %c, i64 0, i32 0, i32 0, i32 0
|
||||
store i32 7, i32* %C_b, align 4, !tbaa !9 ; TAG_C_b
|
||||
%0 = load i32, i32* %i, align 4, !tbaa !12 ; TAG_short
|
||||
ret i32 %0
|
||||
}
|
||||
|
||||
; C vs. D => NoAlias.
|
||||
define i32 @f6(%C* %c, %D* %d) {
|
||||
entry:
|
||||
; CHECK-LABEL: f6
|
||||
; CHECK: NoAlias: store i16 7, {{.*}} <-> store i32 5,
|
||||
; OPT-LABEL: f6
|
||||
; OPT: store i32 5,
|
||||
; OPT: store i16 7,
|
||||
; OPT: ret i32 5
|
||||
%cp = getelementptr inbounds %C, %C* %c, i64 0, i32 0, i32 0, i32 0
|
||||
store i32 5, i32* %cp, align 4, !tbaa !13 ; TAG_C
|
||||
%dp = getelementptr inbounds %D, %D* %d, i64 0, i32 0
|
||||
store i16 7, i16* %dp, align 4, !tbaa !15 ; TAG_D
|
||||
%0 = load i32, i32* %cp, align 4, !tbaa !13 ; TAG_C
|
||||
ret i32 %0
|
||||
}
|
||||
|
||||
!0 = !{!"root"}
|
||||
!1 = !{!0, i64 1, !"char"}
|
||||
!2 = !{!1, i64 4, !"int"}
|
||||
!3 = !{!2, !2, i64 0, i64 4} ; TAG_int
|
||||
|
||||
!4 = !{!1, i64 4, !"A", !2, i64 0, i64 4}
|
||||
!5 = !{!4, !2, i64 0, i64 4} ; TAG_A_i
|
||||
|
||||
!6 = !{!1, i64 4, !"B", !4, i64 0, i64 4}
|
||||
!7 = !{!6, !4, i64 0, i64 4} ; TAG_B_a
|
||||
|
||||
!8 = !{!1, i64 4, !"C", !6, i64 0, i64 4}
|
||||
!9 = !{!8, !6, i64 0, i64 4} ; TAG_C_b
|
||||
|
||||
!10 = !{!4, !4, i64 0, i64 4} ; TAG_A
|
||||
|
||||
!11 = !{!1, i64 2, !"short"}
|
||||
!12 = !{!11, !11, i64 0, i64 2} ; TAG_short
|
||||
|
||||
!13 = !{!8, !8, i64 0, i64 4} ; TAG_C
|
||||
|
||||
!14 = !{!4, i64 2, !"D", !11, i64 0, i64 2}
|
||||
!15 = !{!14, !14, i64 0, i64 2} ; TAG_D
|
||||
306
llvm/test/Analysis/TypeBasedAliasAnalysis/tbaa-path-new.ll
Normal file
306
llvm/test/Analysis/TypeBasedAliasAnalysis/tbaa-path-new.ll
Normal file
@ -0,0 +1,306 @@
|
||||
; RUN: opt < %s -tbaa -basicaa -aa-eval -evaluate-aa-metadata -print-no-aliases -print-may-aliases -disable-output 2>&1 | FileCheck %s
|
||||
; RUN: opt < %s -tbaa -basicaa -gvn -S | FileCheck %s --check-prefix=OPT
|
||||
; Generated from clang/test/CodeGen/tbaa.cpp with "-O1 -new-struct-path-tbaa".
|
||||
|
||||
%struct.StructA = type { i16, i32, i16, i32 }
|
||||
%struct.StructB = type { i16, %struct.StructA, i32 }
|
||||
%struct.StructS = type { i16, i32 }
|
||||
%struct.StructS2 = type { i16, i32 }
|
||||
%struct.StructC = type { i16, %struct.StructB, i32 }
|
||||
%struct.StructD = type { i16, %struct.StructB, i32, i8 }
|
||||
|
||||
; uint32_t g(uint32_t *s, StructA *A, uint64_t count) {
|
||||
; *s = 1;
|
||||
; A->f32 = 4;
|
||||
; return *s;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z1gPjP7StructAy(i32* nocapture %s, %struct.StructA* nocapture %A, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: Z1gPjP7StructAy
|
||||
; CHECK: MayAlias: store i32 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z1gPjP7StructAy
|
||||
; OPT: store i32 1,
|
||||
; OPT: store i32 4,
|
||||
; OPT: %[[RET:.*]] = load i32,
|
||||
; OPT: ret i32 %[[RET]]
|
||||
store i32 1, i32* %s, align 4, !tbaa !2
|
||||
%f32 = getelementptr inbounds %struct.StructA, %struct.StructA* %A, i64 0, i32 1
|
||||
store i32 4, i32* %f32, align 4, !tbaa !6
|
||||
%0 = load i32, i32* %s, align 4, !tbaa !2
|
||||
ret i32 %0
|
||||
}
|
||||
|
||||
; uint32_t g2(uint32_t *s, StructA *A, uint64_t count) {
|
||||
; *s = 1;
|
||||
; A->f16 = 4;
|
||||
; return *s;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z2g2PjP7StructAy(i32* nocapture %s, %struct.StructA* nocapture %A, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: _Z2g2PjP7StructAy
|
||||
; CHECK: NoAlias: store i16 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z2g2PjP7StructAy
|
||||
; OPT: store i32 1,
|
||||
; OPT: store i16 4,
|
||||
; Remove a load and propagate the value from store.
|
||||
; OPT: ret i32 1
|
||||
store i32 1, i32* %s, align 4, !tbaa !2
|
||||
%f16 = getelementptr inbounds %struct.StructA, %struct.StructA* %A, i64 0, i32 0
|
||||
store i16 4, i16* %f16, align 4, !tbaa !9
|
||||
ret i32 1
|
||||
}
|
||||
|
||||
; uint32_t g3(StructA *A, StructB *B, uint64_t count) {
|
||||
; A->f32 = 1;
|
||||
; B->a.f32 = 4;
|
||||
; return A->f32;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z2g3P7StructAP7StructBy(%struct.StructA* nocapture %A, %struct.StructB* nocapture %B, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: _Z2g3P7StructAP7StructBy
|
||||
; CHECK: MayAlias: store i32 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z2g3P7StructAP7StructBy
|
||||
; OPT: store i32 1
|
||||
; OPT: store i32 4
|
||||
; OPT: %[[RET:.*]] = load i32,
|
||||
; OPT: ret i32 %[[RET]]
|
||||
%f32 = getelementptr inbounds %struct.StructA, %struct.StructA* %A, i64 0, i32 1
|
||||
store i32 1, i32* %f32, align 4, !tbaa !6
|
||||
%f321 = getelementptr inbounds %struct.StructB, %struct.StructB* %B, i64 0, i32 1, i32 1
|
||||
store i32 4, i32* %f321, align 4, !tbaa !10
|
||||
%0 = load i32, i32* %f32, align 4, !tbaa !6
|
||||
ret i32 %0
|
||||
}
|
||||
|
||||
; uint32_t g4(StructA *A, StructB *B, uint64_t count) {
|
||||
; A->f32 = 1;
|
||||
; B->a.f16 = 4;
|
||||
; return A->f32;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z2g4P7StructAP7StructBy(%struct.StructA* nocapture %A, %struct.StructB* nocapture %B, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: _Z2g4P7StructAP7StructBy
|
||||
; CHECK: NoAlias: store i16 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z2g4P7StructAP7StructBy
|
||||
; OPT: store i32 1,
|
||||
; OPT: store i16 4,
|
||||
; Remove a load and propagate the value from store.
|
||||
; OPT: ret i32 1
|
||||
%f32 = getelementptr inbounds %struct.StructA, %struct.StructA* %A, i64 0, i32 1
|
||||
store i32 1, i32* %f32, align 4, !tbaa !6
|
||||
%f16 = getelementptr inbounds %struct.StructB, %struct.StructB* %B, i64 0, i32 1, i32 0
|
||||
store i16 4, i16* %f16, align 4, !tbaa !12
|
||||
ret i32 1
|
||||
}
|
||||
|
||||
; uint32_t g5(StructA *A, StructB *B, uint64_t count) {
|
||||
; A->f32 = 1;
|
||||
; B->f32 = 4;
|
||||
; return A->f32;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z2g5P7StructAP7StructBy(%struct.StructA* nocapture %A, %struct.StructB* nocapture %B, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: _Z2g5P7StructAP7StructBy
|
||||
; CHECK: NoAlias: store i32 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z2g5P7StructAP7StructBy
|
||||
; OPT: store i32 1,
|
||||
; OPT: store i32 4,
|
||||
; Remove a load and propagate the value from store.
|
||||
; OPT: ret i32 1
|
||||
%f32 = getelementptr inbounds %struct.StructA, %struct.StructA* %A, i64 0, i32 1
|
||||
store i32 1, i32* %f32, align 4, !tbaa !6
|
||||
%f321 = getelementptr inbounds %struct.StructB, %struct.StructB* %B, i64 0, i32 2
|
||||
store i32 4, i32* %f321, align 4, !tbaa !13
|
||||
ret i32 1
|
||||
}
|
||||
|
||||
; uint32_t g6(StructA *A, StructB *B, uint64_t count) {
|
||||
; A->f32 = 1;
|
||||
; B->a.f32_2 = 4;
|
||||
; return A->f32;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z2g6P7StructAP7StructBy(%struct.StructA* nocapture %A, %struct.StructB* nocapture %B, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: _Z2g6P7StructAP7StructBy
|
||||
; CHECK: NoAlias: store i32 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z2g6P7StructAP7StructBy
|
||||
; OPT: store i32 1,
|
||||
; OPT: store i32 4,
|
||||
; Remove a load and propagate the value from store.
|
||||
; OPT: ret i32 1
|
||||
%f32 = getelementptr inbounds %struct.StructA, %struct.StructA* %A, i64 0, i32 1
|
||||
store i32 1, i32* %f32, align 4, !tbaa !6
|
||||
%f32_2 = getelementptr inbounds %struct.StructB, %struct.StructB* %B, i64 0, i32 1, i32 3
|
||||
store i32 4, i32* %f32_2, align 4, !tbaa !14
|
||||
ret i32 1
|
||||
}
|
||||
|
||||
; uint32_t g7(StructA *A, StructS *S, uint64_t count) {
|
||||
; A->f32 = 1;
|
||||
; S->f32 = 4;
|
||||
; return A->f32;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z2g7P7StructAP7StructSy(%struct.StructA* nocapture %A, %struct.StructS* nocapture %S, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: _Z2g7P7StructAP7StructSy
|
||||
; CHECK: NoAlias: store i32 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z2g7P7StructAP7StructSy
|
||||
; OPT: store i32 1,
|
||||
; OPT: store i32 4,
|
||||
; Remove a load and propagate the value from store.
|
||||
; OPT: ret i32 1
|
||||
%f32 = getelementptr inbounds %struct.StructA, %struct.StructA* %A, i64 0, i32 1
|
||||
store i32 1, i32* %f32, align 4, !tbaa !6
|
||||
%f321 = getelementptr inbounds %struct.StructS, %struct.StructS* %S, i64 0, i32 1
|
||||
store i32 4, i32* %f321, align 4, !tbaa !15
|
||||
ret i32 1
|
||||
}
|
||||
|
||||
; uint32_t g8(StructA *A, StructS *S, uint64_t count) {
|
||||
; A->f32 = 1;
|
||||
; S->f16 = 4;
|
||||
; return A->f32;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z2g8P7StructAP7StructSy(%struct.StructA* nocapture %A, %struct.StructS* nocapture %S, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: _Z2g8P7StructAP7StructSy
|
||||
; CHECK: NoAlias: store i16 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z2g8P7StructAP7StructSy
|
||||
; OPT: store i32 1,
|
||||
; OPT: store i16 4,
|
||||
; Remove a load and propagate the value from store.
|
||||
; OPT: ret i32 1
|
||||
%f32 = getelementptr inbounds %struct.StructA, %struct.StructA* %A, i64 0, i32 1
|
||||
store i32 1, i32* %f32, align 4, !tbaa !6
|
||||
%f16 = getelementptr inbounds %struct.StructS, %struct.StructS* %S, i64 0, i32 0
|
||||
store i16 4, i16* %f16, align 4, !tbaa !17
|
||||
ret i32 1
|
||||
}
|
||||
|
||||
; uint32_t g9(StructS *S, StructS2 *S2, uint64_t count) {
|
||||
; S->f32 = 1;
|
||||
; S2->f32 = 4;
|
||||
; return S->f32;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z2g9P7StructSP8StructS2y(%struct.StructS* nocapture %S, %struct.StructS2* nocapture %S2, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: _Z2g9P7StructSP8StructS2y
|
||||
; CHECK: NoAlias: store i32 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z2g9P7StructSP8StructS2y
|
||||
; OPT: store i32 1,
|
||||
; OPT: store i32 4,
|
||||
; Remove a load and propagate the value from store.
|
||||
; OPT: ret i32 1
|
||||
%f32 = getelementptr inbounds %struct.StructS, %struct.StructS* %S, i64 0, i32 1
|
||||
store i32 1, i32* %f32, align 4, !tbaa !15
|
||||
%f321 = getelementptr inbounds %struct.StructS2, %struct.StructS2* %S2, i64 0, i32 1
|
||||
store i32 4, i32* %f321, align 4, !tbaa !18
|
||||
ret i32 1
|
||||
}
|
||||
|
||||
; uint32_t g10(StructS *S, StructS2 *S2, uint64_t count) {
|
||||
; S->f32 = 1;
|
||||
; S2->f16 = 4;
|
||||
; return S->f32;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z3g10P7StructSP8StructS2y(%struct.StructS* nocapture %S, %struct.StructS2* nocapture %S2, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: _Z3g10P7StructSP8StructS2y
|
||||
; CHECK: NoAlias: store i16 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z3g10P7StructSP8StructS2y
|
||||
; OPT: store i32 1,
|
||||
; OPT: store i16 4,
|
||||
; Remove a load and propagate the value from store.
|
||||
; OPT: ret i32 1
|
||||
%f32 = getelementptr inbounds %struct.StructS, %struct.StructS* %S, i64 0, i32 1
|
||||
store i32 1, i32* %f32, align 4, !tbaa !15
|
||||
%f16 = getelementptr inbounds %struct.StructS2, %struct.StructS2* %S2, i64 0, i32 0
|
||||
store i16 4, i16* %f16, align 4, !tbaa !20
|
||||
ret i32 1
|
||||
}
|
||||
|
||||
; uint32_t g11(StructC *C, StructD *D, uint64_t count) {
|
||||
; C->b.a.f32 = 1;
|
||||
; D->b.a.f32 = 4;
|
||||
; return C->b.a.f32;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z3g11P7StructCP7StructDy(%struct.StructC* nocapture %C, %struct.StructD* nocapture %D, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: _Z3g11P7StructCP7StructDy
|
||||
; CHECK: NoAlias: store i32 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z3g11P7StructCP7StructDy
|
||||
; OPT: store i32 1,
|
||||
; OPT: store i32 4,
|
||||
; Remove a load and propagate the value from store.
|
||||
; OPT: ret i32 1
|
||||
%f32 = getelementptr inbounds %struct.StructC, %struct.StructC* %C, i64 0, i32 1, i32 1, i32 1
|
||||
store i32 1, i32* %f32, align 4, !tbaa !21
|
||||
%f323 = getelementptr inbounds %struct.StructD, %struct.StructD* %D, i64 0, i32 1, i32 1, i32 1
|
||||
store i32 4, i32* %f323, align 4, !tbaa !23
|
||||
ret i32 1
|
||||
}
|
||||
|
||||
; uint32_t g12(StructC *C, StructD *D, uint64_t count) {
|
||||
; StructB *b1 = &(C->b);
|
||||
; StructB *b2 = &(D->b);
|
||||
; // b1, b2 have different context.
|
||||
; b1->a.f32 = 1;
|
||||
; b2->a.f32 = 4;
|
||||
; return b1->a.f32;
|
||||
; }
|
||||
;
|
||||
define i32 @_Z3g12P7StructCP7StructDy(%struct.StructC* nocapture %C, %struct.StructD* nocapture %D, i64 %count) {
|
||||
entry:
|
||||
; CHECK-LABEL: _Z3g12P7StructCP7StructDy
|
||||
; CHECK: MayAlias: store i32 4, {{.*}} <-> store i32 1,
|
||||
; OPT-LABEL: _Z3g12P7StructCP7StructDy
|
||||
; OPT: store i32 1,
|
||||
; OPT: store i32 4,
|
||||
; OPT: %[[RET:.*]] = load i32,
|
||||
; OPT: ret i32 %[[RET]]
|
||||
%f32 = getelementptr inbounds %struct.StructC, %struct.StructC* %C, i64 0, i32 1, i32 1, i32 1
|
||||
store i32 1, i32* %f32, align 4, !tbaa !10
|
||||
%f325 = getelementptr inbounds %struct.StructD, %struct.StructD* %D, i64 0, i32 1, i32 1, i32 1
|
||||
store i32 4, i32* %f325, align 4, !tbaa !10
|
||||
%0 = load i32, i32* %f32, align 4, !tbaa !10
|
||||
ret i32 %0
|
||||
}
|
||||
|
||||
!2 = !{!3, !3, i64 0, i64 4}
|
||||
!3 = !{!4, i64 4, !"int"}
|
||||
!4 = !{!5, i64 1, !"omnipotent char"}
|
||||
!5 = !{!"Simple C++ TBAA"}
|
||||
!6 = !{!7, !3, i64 4, i64 4}
|
||||
!7 = !{!4, i64 16, !"_ZTS7StructA", !8, i64 0, i64 2, !3, i64 4, i64 4, !8, i64 8, i64 2, !3, i64 12, i64 4}
|
||||
!8 = !{!4, i64 2, !"short"}
|
||||
!9 = !{!7, !8, i64 0, i64 2}
|
||||
!10 = !{!11, !3, i64 8, i64 4}
|
||||
!11 = !{!4, i64 24, !"_ZTS7StructB", !8, i64 0, i64 2, !7, i64 4, i64 16, !3, i64 20, i64 4}
|
||||
!12 = !{!11, !8, i64 4, i64 2}
|
||||
!13 = !{!11, !3, i64 20, i64 4}
|
||||
!14 = !{!11, !3, i64 16, i64 4}
|
||||
!15 = !{!16, !3, i64 4, i64 4}
|
||||
!16 = !{!4, i64 8, !"_ZTS7StructS", !8, i64 0, i64 2, !3, i64 4, i64 4}
|
||||
!17 = !{!16, !8, i64 0, i64 2}
|
||||
!18 = !{!19, !3, i64 4, i64 4}
|
||||
!19 = !{!4, i64 8, !"_ZTS8StructS2", !8, i64 0, i64 2, !3, i64 4, i64 4}
|
||||
!20 = !{!19, !8, i64 0, i64 2}
|
||||
!21 = !{!22, !3, i64 12, i64 4}
|
||||
!22 = !{!4, i64 32, !"_ZTS7StructC", !8, i64 0, i64 2, !11, i64 4, i64 24, !3, i64 28, i64 4}
|
||||
!23 = !{!24, !3, i64 12, i64 4}
|
||||
!24 = !{!4, i64 36, !"_ZTS7StructD", !8, i64 0, i64 2, !11, i64 4, i64 24, !3, i64 28, i64 4, !4, i64 32, i64 1}
|
||||
!25 = !{!26, !4, i64 1, i64 1}
|
||||
!26 = !{!4, i64 3, !"_ZTS4five", !4, i64 0, i64 1, !3, i64 1, i64 4, !4, i64 1, i64 1, !4, i64 2, i64 1}
|
||||
!27 = !{!28, !4, i64 4, i64 1}
|
||||
!28 = !{!4, i64 6, !"_ZTS3six", !4, i64 0, i64 1, !3, i64 4, i64 4, !4, i64 4, i64 1, !4, i64 5, i64 1}
|
||||
Loading…
Reference in New Issue
Block a user