maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/unittests/CodeGen/TBAAMetadataTest.cpp

1299 lines
29 KiB
C++
Raw Blame History

//=== unittests/CodeGen/TBAAMetadataTest.cpp - Checks metadata generation -===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "IRMatchers.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/CodeGen/ModuleBuilder.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Parse/ParseAST.h"
#include "llvm/ADT/Triple.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/MemoryBuffer.h"
#include "gtest/gtest.h"
#include <memory>
using namespace llvm;
namespace {
struct TestCompiler {
LLVMContext Context;
clang::CompilerInstance compiler;
clang::CodeGenerator *CG = nullptr;
llvm::Module *M = nullptr;
unsigned PtrSize = 0;
void init(const char *TestProgram) {
compiler.createDiagnostics();
compiler.getCodeGenOpts().StructPathTBAA = 1;
compiler.getCodeGenOpts().OptimizationLevel = 1;
std::string TrStr = llvm::Triple::normalize(llvm::sys::getProcessTriple());
llvm::Triple Tr(TrStr);
Tr.setOS(Triple::Linux);
Tr.setVendor(Triple::VendorType::UnknownVendor);
Tr.setEnvironment(Triple::EnvironmentType::UnknownEnvironment);
compiler.getTargetOpts().Triple = Tr.getTriple();
compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
compiler.getDiagnostics(),
std::make_shared<clang::TargetOptions>(compiler.getTargetOpts())));
const clang::TargetInfo &TInfo = compiler.getTarget();
PtrSize = TInfo.getPointerWidth(0) / 8;
compiler.createFileManager();
compiler.createSourceManager(compiler.getFileManager());
compiler.createPreprocessor(clang::TU_Prefix);
compiler.createASTContext();
CG = CreateLLVMCodeGen(
compiler.getDiagnostics(),
"main-module",
compiler.getHeaderSearchOpts(),
compiler.getPreprocessorOpts(),
compiler.getCodeGenOpts(),
Context);
compiler.setASTConsumer(std::unique_ptr<clang::ASTConsumer>(CG));
compiler.createSema(clang::TU_Prefix, nullptr);
clang::SourceManager &sm = compiler.getSourceManager();
sm.setMainFileID(sm.createFileID(
llvm::MemoryBuffer::getMemBuffer(TestProgram), clang::SrcMgr::C_User));
}
const BasicBlock *compile() {
clang::ParseAST(compiler.getSema(), false, false);
M = CG->GetModule();
// Do not expect more than one function definition.
auto FuncPtr = M->begin();
for (; FuncPtr != M->end(); ++FuncPtr)
if (!FuncPtr->isDeclaration())
break;
assert(FuncPtr != M->end());
const llvm::Function &Func = *FuncPtr;
++FuncPtr;
for (; FuncPtr != M->end(); ++FuncPtr)
if (!FuncPtr->isDeclaration())
break;
assert(FuncPtr == M->end());
// The function must consist of single basic block.
auto BBPtr = Func.begin();
assert(Func.begin() != Func.end());
const BasicBlock &BB = *BBPtr;
++BBPtr;
assert(BBPtr == Func.end());
return &BB;
}
};
auto OmnipotentCharC = MMTuple(
MMString("omnipotent char"),
MMTuple(
MMString("Simple C/C++ TBAA")),
MConstInt(0, 64)
);
auto OmnipotentCharCXX = MMTuple(
MMString("omnipotent char"),
MMTuple(
MMString("Simple C++ TBAA")),
MConstInt(0, 64)
);
TEST(TBAAMetadataTest, BasicTypes) {
const char TestProgram[] = R"**(
void func(char *CP, short *SP, int *IP, long long *LP, void **VPP,
int **IPP) {
*CP = 4;
*SP = 11;
*IP = 601;
*LP = 604;
*VPP = CP;
*IPP = IP;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().C11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(4, 8),
MMTuple(
OmnipotentCharC,
MSameAs(0),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(11, 16),
MMTuple(
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MSameAs(0),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(601, 32),
MMTuple(
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MSameAs(0),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(604, 64),
MMTuple(
MMTuple(
MMString("long long"),
OmnipotentCharC,
MConstInt(0)),
MSameAs(0),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MValType(Type::getInt8PtrTy(Compiler.Context)),
MMTuple(
MMTuple(
MMString("any pointer"),
OmnipotentCharC,
MConstInt(0)),
MSameAs(0),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MValType(Type::getInt32PtrTy(Compiler.Context)),
MMTuple(
MMTuple(
MMString("any pointer"),
OmnipotentCharC,
MConstInt(0)),
MSameAs(0),
MConstInt(0))));
ASSERT_TRUE(I);
}
TEST(TBAAMetadataTest, CFields) {
const char TestProgram[] = R"**(
struct ABC {
short f16;
int f32;
long long f64;
unsigned short f16_2;
unsigned f32_2;
unsigned long long f64_2;
};
void func(struct ABC *A) {
A->f32 = 4;
A->f16 = 11;
A->f64 = 601;
A->f16_2 = 22;
A->f32_2 = 77;
A->f64_2 = 604;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().C11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto StructABC = MMTuple(
MMString("ABC"),
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0),
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4),
MMTuple(
MMString("long long"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(8),
MSameAs(1),
MConstInt(16),
MSameAs(3),
MConstInt(20),
MSameAs(5),
MConstInt(24));
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(4, 32),
MMTuple(
StructABC,
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(11, 16),
MMTuple(
StructABC,
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(601, 64),
MMTuple(
StructABC,
MMTuple(
MMString("long long"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(8))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(22, 16),
MMTuple(
StructABC,
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(16))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(77, 32),
MMTuple(
StructABC,
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(20))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(604, 64),
MMTuple(
StructABC,
MMTuple(
MMString("long long"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(24))));
ASSERT_TRUE(I);
}
TEST(TBAAMetadataTest, CTypedefFields) {
const char TestProgram[] = R"**(
typedef struct {
short f16;
int f32;
} ABC;
typedef struct {
short value_f16;
int value_f32;
} CDE;
void func(ABC *A, CDE *B) {
A->f32 = 4;
A->f16 = 11;
B->value_f32 = 44;
B->value_f16 = 111;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().C11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto NamelessStruct = MMTuple(
MMString(""),
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0),
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4));
const Metadata *MetaABC = nullptr;
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(4, 32),
MMTuple(
MMSave(MetaABC, NamelessStruct),
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(11, 16),
MMTuple(
NamelessStruct,
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
const Metadata *MetaCDE = nullptr;
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(44, 32),
MMTuple(
MMSave(MetaCDE, NamelessStruct),
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(111, 16),
MMTuple(
NamelessStruct,
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
// FIXME: Nameless structures used in definitions of 'ABC' and 'CDE' are
// different structures and must be described by different descriptors.
//ASSERT_TRUE(MetaABC != MetaCDE);
}
TEST(TBAAMetadataTest, CTypedefFields2) {
const char TestProgram[] = R"**(
typedef struct {
short f16;
int f32;
} ABC;
typedef struct {
short f16;
int f32;
} CDE;
void func(ABC *A, CDE *B) {
A->f32 = 4;
A->f16 = 11;
B->f32 = 44;
B->f16 = 111;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().C11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto NamelessStruct = MMTuple(
MMString(""),
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0),
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4));
const Metadata *MetaABC = nullptr;
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(4, 32),
MMTuple(
MMSave(MetaABC, NamelessStruct),
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(11, 16),
MMTuple(
NamelessStruct,
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
const Metadata *MetaCDE = nullptr;
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(44, 32),
MMTuple(
MMSave(MetaCDE, NamelessStruct),
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(111, 16),
MMTuple(
NamelessStruct,
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
// FIXME: Nameless structures used in definitions of 'ABC' and 'CDE' are
// different structures, although they have the same field sequence. They must
// be described by different descriptors.
//ASSERT_TRUE(MetaABC != MetaCDE);
}
TEST(TBAAMetadataTest, CTypedefFields3) {
const char TestProgram[] = R"**(
typedef struct {
short f16;
int f32;
} ABC;
typedef struct {
int f32;
short f16;
} CDE;
void func(ABC *A, CDE *B) {
A->f32 = 4;
A->f16 = 11;
B->f32 = 44;
B->f16 = 111;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().C11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto NamelessStruct1 = MMTuple(
MMString(""),
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0),
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4));
auto NamelessStruct2 = MMTuple(
MMString(""),
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0),
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4));
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(4, 32),
MMTuple(
NamelessStruct1,
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(11, 16),
MMTuple(
NamelessStruct1,
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(44, 32),
MMTuple(
NamelessStruct2,
MMTuple(
MMString("int"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(111, 16),
MMTuple(
NamelessStruct2,
MMTuple(
MMString("short"),
OmnipotentCharC,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
}
TEST(TBAAMetadataTest, CXXFields) {
const char TestProgram[] = R"**(
struct ABC {
short f16;
int f32;
long long f64;
unsigned short f16_2;
unsigned f32_2;
unsigned long long f64_2;
};
void func(struct ABC *A) {
A->f32 = 4;
A->f16 = 11;
A->f64 = 601;
A->f16_2 = 22;
A->f32_2 = 77;
A->f64_2 = 604;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().CPlusPlus = 1;
Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto StructABC = MMTuple(
MMString("_ZTS3ABC"),
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0),
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(4),
MMTuple(
MMString("long long"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(8),
MSameAs(1),
MConstInt(16),
MSameAs(3),
MConstInt(20),
MSameAs(5),
MConstInt(24));
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(4, 32),
MMTuple(
StructABC,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(11, 16),
MMTuple(
StructABC,
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(601, 64),
MMTuple(
StructABC,
MMTuple(
MMString("long long"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(8))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(22, 16),
MMTuple(
StructABC,
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(16))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(77, 32),
MMTuple(
StructABC,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(20))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(604, 64),
MMTuple(
StructABC,
MMTuple(
MMString("long long"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(24))));
ASSERT_TRUE(I);
}
TEST(TBAAMetadataTest, CXXTypedefFields) {
const char TestProgram[] = R"**(
typedef struct {
short f16;
int f32;
} ABC;
typedef struct {
short value_f16;
int value_f32;
} CDE;
void func(ABC *A, CDE *B) {
A->f32 = 4;
A->f16 = 11;
B->value_f32 = 44;
B->value_f16 = 111;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().CPlusPlus = 1;
Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto StructABC = MMTuple(
MMString("_ZTS3ABC"),
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0),
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(4));
auto StructCDE = MMTuple(
MMString("_ZTS3CDE"),
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0),
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(4));
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(4, 32),
MMTuple(
StructABC,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(11, 16),
MMTuple(
StructABC,
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(44, 32),
MMTuple(
StructCDE,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(111, 16),
MMTuple(
StructCDE,
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
}
TEST(TBAAMetadataTest, StructureFields) {
const char TestProgram[] = R"**(
struct Inner {
int f32;
};
struct Outer {
short f16;
Inner b1;
Inner b2;
};
void func(Outer *S) {
S->f16 = 14;
S->b1.f32 = 35;
S->b2.f32 = 77;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().CPlusPlus = 1;
Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto StructInner = MMTuple(
MMString("_ZTS5Inner"),
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0));
auto StructOuter = MMTuple(
MMString("_ZTS5Outer"),
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0),
StructInner,
MConstInt(4),
MSameAs(3),
MConstInt(8));
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(14, 16),
MMTuple(
StructOuter,
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(35, 32),
MMTuple(
StructOuter,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(77, 32),
MMTuple(
StructOuter,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(8))));
ASSERT_TRUE(I);
}
TEST(TBAAMetadataTest, ArrayFields) {
const char TestProgram[] = R"**(
struct Inner {
int f32;
};
struct Outer {
short f16;
Inner b1[2];
};
void func(Outer *S) {
S->f16 = 14;
S->b1[0].f32 = 35;
S->b1[1].f32 = 77;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().CPlusPlus = 1;
Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto StructInner = MMTuple(
MMString("_ZTS5Inner"),
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0));
auto StructOuter = MMTuple(
MMString("_ZTS5Outer"),
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0),
OmnipotentCharCXX, // FIXME: Info about array field is lost.
MConstInt(4));
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(14, 16),
MMTuple(
StructOuter,
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(35, 32),
MMTuple(
StructInner,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(77, 32),
MMTuple(
StructInner,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
}
TEST(TBAAMetadataTest, BaseClass) {
const char TestProgram[] = R"**(
struct Base {
int f32;
};
struct Derived : public Base {
short f16;
};
void func(Base *B, Derived *D) {
B->f32 = 14;
D->f16 = 35;
D->f32 = 77;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().CPlusPlus = 1;
Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto ClassBase = MMTuple(
MMString("_ZTS4Base"),
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0));
auto ClassDerived = MMTuple(
MMString("_ZTS7Derived"),
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(4));
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(14, 32),
MMTuple(
ClassBase,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(35, 16),
MMTuple(
ClassDerived,
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(77, 32),
MMTuple(
ClassBase,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
}
TEST(TBAAMetadataTest, PolymorphicClass) {
const char TestProgram[] = R"**(
struct Base {
virtual void m1(int *) = 0;
int f32;
};
struct Derived : public Base {
virtual void m1(int *) override;
short f16;
};
void func(Base *B, Derived *D) {
B->f32 = 14;
D->f16 = 35;
D->f32 = 77;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().CPlusPlus = 1;
Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto ClassBase = MMTuple(
MMString("_ZTS4Base"),
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(Compiler.PtrSize));
auto ClassDerived = MMTuple(
MMString("_ZTS7Derived"),
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(Compiler.PtrSize + 4));
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(14, 32),
MMTuple(
ClassBase,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(Compiler.PtrSize))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(35, 16),
MMTuple(
ClassDerived,
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(Compiler.PtrSize + 4))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(77, 32),
MMTuple(
ClassBase,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(Compiler.PtrSize))));
ASSERT_TRUE(I);
}
TEST(TBAAMetadataTest, VirtualBase) {
const char TestProgram[] = R"**(
struct Base {
int f32;
};
struct Derived : public virtual Base {
short f16;
};
void func(Base *B, Derived *D) {
B->f32 = 14;
D->f16 = 35;
D->f32 = 77;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().CPlusPlus = 1;
Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto ClassBase = MMTuple(
MMString("_ZTS4Base"),
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0));
auto ClassDerived = MMTuple(
MMString("_ZTS7Derived"),
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(Compiler.PtrSize));
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MConstInt(14, 32),
MMTuple(
ClassBase,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(35, 16),
MMTuple(
ClassDerived,
MMTuple(
MMString("short"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(Compiler.PtrSize))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Load,
MMTuple(
MMTuple(
MMString("vtable pointer"),
MMTuple(
MMString("Simple C++ TBAA")),
MConstInt(0)),
MSameAs(0),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(77, 32),
MMTuple(
ClassBase,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
}
TEST(TBAAMetadataTest, TemplSpec) {
const char TestProgram[] = R"**(
template<typename T1, typename T2>
struct ABC {
T1 f1;
T2 f2;
};
void func(ABC<double, int> *p) {
p->f1 = 12.1;
p->f2 = 44;
}
)**";
TestCompiler Compiler;
Compiler.compiler.getLangOpts().CPlusPlus = 1;
Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
auto SpecABC = MMTuple(
MMString("_ZTS3ABCIdiE"),
MMTuple(
MMString("double"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0),
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(8));
const Instruction *I = match(BB,
MInstruction(Instruction::Store,
MValType(MType([](const Type &T)->bool { return T.isDoubleTy(); })),
MMTuple(
SpecABC,
MMTuple(
MMString("double"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(0))));
ASSERT_TRUE(I);
I = matchNext(I,
MInstruction(Instruction::Store,
MConstInt(44, 32),
MMTuple(
SpecABC,
MMTuple(
MMString("int"),
OmnipotentCharCXX,
MConstInt(0)),
MConstInt(8))));
ASSERT_TRUE(I);
}
}
Reference in New Issue View Git Blame Copy Permalink