From b2bd7e89e64b73be1c412ba8942b40c106b3f070 Mon Sep 17 00:00:00 2001 From: Juergen Ributzka Date: Sat, 3 May 2014 22:32:52 +0000 Subject: [PATCH] [TBAA] Fix handling of mixed TBAA (path-aware and non-path-aware TBAA). This fix simply ensures that both metadata nodes are path-aware before performing path-aware alias analysis. This issue isn't normally triggered in LLVM, because we perform an autoupgrade of the TBAA metadata to the new format when reading in LL or BC files. This issue only appears when a client creates the IR manually and mixes old and new TBAA metadata format. This fixes . git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207923 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Analysis/TypeBasedAliasAnalysis.cpp | 9 ++- unittests/Analysis/CMakeLists.txt | 1 + unittests/Analysis/MixedTBAATest.cpp | 77 +++++++++++++++++++++++++ 3 files changed, 85 insertions(+), 2 deletions(-) create mode 100644 unittests/Analysis/MixedTBAATest.cpp diff --git a/lib/Analysis/TypeBasedAliasAnalysis.cpp b/lib/Analysis/TypeBasedAliasAnalysis.cpp index 6738720db95..f36f6f8a876 100644 --- a/lib/Analysis/TypeBasedAliasAnalysis.cpp +++ b/lib/Analysis/TypeBasedAliasAnalysis.cpp @@ -339,7 +339,8 @@ static bool isStructPathTBAA(const MDNode *MD) { bool TypeBasedAliasAnalysis::Aliases(const MDNode *A, const MDNode *B) const { - if (isStructPathTBAA(A)) + // Make sure that both MDNodes are struct-path aware. + if (isStructPathTBAA(A) && isStructPathTBAA(B)) return PathAliases(A, B); // Keep track of the root node for A and B. @@ -385,6 +386,10 @@ TypeBasedAliasAnalysis::Aliases(const MDNode *A, bool TypeBasedAliasAnalysis::PathAliases(const MDNode *A, const MDNode *B) const { + // Verify that both input nodes are struct-path aware. + assert(isStructPathTBAA(A) && "MDNode A is not struct-path aware."); + assert(isStructPathTBAA(B) && "MDNode B is not struct-path aware."); + // Keep track of the root node for A and B. TBAAStructTypeNode RootA, RootB; TBAAStructTagNode TagA(A), TagB(B); @@ -560,7 +565,7 @@ MDNode *MDNode::getMostGenericTBAA(MDNode *A, MDNode *B) { return A; // For struct-path aware TBAA, we use the access type of the tag. - bool StructPath = isStructPathTBAA(A); + bool StructPath = isStructPathTBAA(A) && isStructPathTBAA(B); if (StructPath) { A = cast_or_null(A->getOperand(1)); if (!A) return nullptr; diff --git a/unittests/Analysis/CMakeLists.txt b/unittests/Analysis/CMakeLists.txt index 5cca8e8d214..84548609ede 100644 --- a/unittests/Analysis/CMakeLists.txt +++ b/unittests/Analysis/CMakeLists.txt @@ -9,4 +9,5 @@ add_llvm_unittest(AnalysisTests CFGTest.cpp LazyCallGraphTest.cpp ScalarEvolutionTest.cpp + MixedTBAATest.cpp ) diff --git a/unittests/Analysis/MixedTBAATest.cpp b/unittests/Analysis/MixedTBAATest.cpp new file mode 100644 index 00000000000..2cf7c734dc6 --- /dev/null +++ b/unittests/Analysis/MixedTBAATest.cpp @@ -0,0 +1,77 @@ +//===--- MixedTBAATest.cpp - Mixed TBAA unit tests ------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Analysis/Passes.h" +#include "llvm/IR/Constants.h" +#include "llvm/IR/Instructions.h" +#include "llvm/IR/LLVMContext.h" +#include "llvm/IR/MDBuilder.h" +#include "llvm/IR/Module.h" +#include "llvm/PassManager.h" +#include "llvm/Support/CommandLine.h" +#include "gtest/gtest.h" + +namespace llvm { +namespace { + +class MixedTBAATest : public testing::Test { +protected: + MixedTBAATest() : M("MixedTBAATest", C), MD(C) {} + + LLVMContext C; + Module M; + MDBuilder MD; + PassManager PM; +}; + +TEST_F(MixedTBAATest, MixedTBAA) { + // Setup function. + FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), + std::vector(), false); + auto *F = cast(M.getOrInsertFunction("f", FTy)); + auto *BB = BasicBlock::Create(C, "entry", F); + auto IntType = Type::getInt32Ty(C); + auto PtrType = Type::getInt32PtrTy(C); + auto *Value = ConstantInt::get(IntType, 42); + auto *Addr = ConstantPointerNull::get(PtrType); + + auto *Store1 = new StoreInst(Value, Addr, BB); + auto *Store2 = new StoreInst(Value, Addr, BB); + ReturnInst::Create(C, 0, BB); + + // New TBAA metadata + { + auto RootMD = MD.createTBAARoot("Simple C/C++ TBAA"); + auto MD1 = MD.createTBAAScalarTypeNode("omnipotent char", RootMD); + auto MD2 = MD.createTBAAScalarTypeNode("int", MD1); + auto MD3 = MD.createTBAAStructTagNode(MD2, MD2, 0); + Store2->setMetadata(LLVMContext::MD_tbaa, MD3); + } + + // Old TBAA metadata + { + auto RootMD = MD.createTBAARoot("Simple C/C++ TBAA"); + auto MD1 = MD.createTBAANode("omnipotent char", RootMD); + auto MD2 = MD.createTBAANode("int", MD1); + Store1->setMetadata(LLVMContext::MD_tbaa, MD2); + } + + // Run the TBAA eval pass on a mixture of path-aware and non-path-aware TBAA. + // The order of the metadata (path-aware vs non-path-aware) is important, + // because the AA eval pass only runs one test per store-pair. + const char* args[] = { "MixedTBAATest", "-evaluate-tbaa" }; + cl::ParseCommandLineOptions(sizeof(args) / sizeof(const char*), args); + PM.add(createTypeBasedAliasAnalysisPass()); + PM.add(createAAEvalPass()); + PM.run(M); +} + +} // end anonymous namspace +} // end llvm namespace +