mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-06-12 13:38:21 +00:00
Initial revision
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
150
lib/Analysis/ModuleAnalyzer.cpp
Normal file
150
lib/Analysis/ModuleAnalyzer.cpp
Normal file
@ -0,0 +1,150 @@
|
||||
//===-- llvm/Analysis/ModuleAnalyzer.cpp - Module analysis driver ----------==//
|
||||
//
|
||||
// This class provides a nice interface to traverse a module in a predictable
|
||||
// way. This is used by the AssemblyWriter, BytecodeWriter, and SlotCalculator
|
||||
// to do analysis of a module.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Analysis/ModuleAnalyzer.h"
|
||||
#include "llvm/ConstantPool.h"
|
||||
#include "llvm/Method.h"
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/BasicBlock.h"
|
||||
#include "llvm/DerivedTypes.h"
|
||||
#include "llvm/ConstPoolVals.h"
|
||||
#include <map>
|
||||
|
||||
// processModule - Driver function to call all of my subclasses virtual methods.
|
||||
//
|
||||
bool ModuleAnalyzer::processModule(const Module *M) {
|
||||
// Loop over the constant pool, process all of the constants...
|
||||
if (processConstPool(M->getConstantPool(), false))
|
||||
return true;
|
||||
|
||||
return processMethods(M);
|
||||
}
|
||||
|
||||
inline bool ModuleAnalyzer::handleType(set<const Type *> &TypeSet,
|
||||
const Type *T) {
|
||||
if (!T->isDerivedType()) return false; // Boring boring types...
|
||||
if (TypeSet.count(T) != 0) return false; // Already found this type...
|
||||
TypeSet.insert(T); // Add it to the set
|
||||
|
||||
// Recursively process interesting types...
|
||||
switch (T->getPrimitiveID()) {
|
||||
case Type::MethodTyID: {
|
||||
const MethodType *MT = (const MethodType *)T;
|
||||
if (handleType(TypeSet, MT->getReturnType())) return true;
|
||||
const MethodType::ParamTypes &Params = MT->getParamTypes();
|
||||
|
||||
for (MethodType::ParamTypes::const_iterator I = Params.begin();
|
||||
I != Params.end(); ++I)
|
||||
if (handleType(TypeSet, *I)) return true;
|
||||
break;
|
||||
}
|
||||
|
||||
case Type::ArrayTyID:
|
||||
if (handleType(TypeSet, ((const ArrayType *)T)->getElementType()))
|
||||
return true;
|
||||
break;
|
||||
|
||||
case Type::StructTyID: {
|
||||
const StructType *ST = (const StructType*)T;
|
||||
const StructType::ElementTypes &Elements = ST->getElementTypes();
|
||||
for (StructType::ElementTypes::const_iterator I = Elements.begin();
|
||||
I != Elements.end(); ++I)
|
||||
if (handleType(TypeSet, *I)) return true;
|
||||
break;
|
||||
}
|
||||
|
||||
case Type::PointerTyID:
|
||||
if (handleType(TypeSet, ((const PointerType *)T)->getValueType()))
|
||||
return true;
|
||||
break;
|
||||
|
||||
default:
|
||||
cerr << "ModuleAnalyzer::handleType, type unknown: '"
|
||||
<< T->getName() << "'\n";
|
||||
break;
|
||||
}
|
||||
|
||||
return processType(T);
|
||||
}
|
||||
|
||||
|
||||
bool ModuleAnalyzer::processConstPool(const ConstantPool &CP, bool isMethod) {
|
||||
// TypeSet - Keep track of which types have already been processType'ed. We
|
||||
// don't want to reprocess the same type more than once.
|
||||
//
|
||||
set<const Type *> TypeSet;
|
||||
|
||||
for (ConstantPool::plane_const_iterator PI = CP.begin();
|
||||
PI != CP.end(); ++PI) {
|
||||
const ConstantPool::PlaneType &Plane = **PI;
|
||||
if (Plane.empty()) continue; // Skip empty type planes...
|
||||
|
||||
if (processConstPoolPlane(CP, Plane, isMethod)) return true;
|
||||
|
||||
for (ConstantPool::PlaneType::const_iterator CI = Plane.begin();
|
||||
CI != Plane.end(); CI++) {
|
||||
if ((*CI)->getType() == Type::TypeTy)
|
||||
if (handleType(TypeSet, ((const ConstPoolType*)(*CI))->getValue()))
|
||||
return true;
|
||||
if (handleType(TypeSet, (*CI)->getType())) return true;
|
||||
|
||||
if (processConstant(*CI)) return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!isMethod) {
|
||||
assert(CP.getParent()->getValueType() == Value::ModuleVal);
|
||||
const Module *M = (const Module*)CP.getParent();
|
||||
// Process the method types after the constant pool...
|
||||
for (Module::MethodListType::const_iterator I = M->getMethodList().begin();
|
||||
I != M->getMethodList().end(); I++) {
|
||||
if (handleType(TypeSet, (*I)->getType())) return true;
|
||||
if (visitMethod(*I)) return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ModuleAnalyzer::processMethods(const Module *M) {
|
||||
for (Module::MethodListType::const_iterator I = M->getMethodList().begin();
|
||||
I != M->getMethodList().end(); I++)
|
||||
if (processMethod(*I)) return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ModuleAnalyzer::processMethod(const Method *M) {
|
||||
// Loop over the arguments, processing them...
|
||||
const Method::ArgumentListType &ArgList = M->getArgumentList();
|
||||
for (Method::ArgumentListType::const_iterator AI = ArgList.begin();
|
||||
AI != ArgList.end(); AI++)
|
||||
if (processMethodArgument(*AI)) return true;
|
||||
|
||||
// Loop over the constant pool, adding the constants to the table...
|
||||
processConstPool(M->getConstantPool(), true);
|
||||
|
||||
// Loop over all the basic blocks, in order...
|
||||
Method::BasicBlocksType::const_iterator BBI = M->getBasicBlocks().begin();
|
||||
for (; BBI != M->getBasicBlocks().end(); BBI++)
|
||||
if (processBasicBlock(*BBI)) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ModuleAnalyzer::processBasicBlock(const BasicBlock *BB) {
|
||||
// Process all of the instructions in the basic block
|
||||
BasicBlock::InstListType::const_iterator Inst = BB->getInstList().begin();
|
||||
for (; Inst != BB->getInstList().end(); Inst++) {
|
||||
if (preProcessInstruction(*Inst) || processInstruction(*Inst)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ModuleAnalyzer::preProcessInstruction(const Instruction *I) {
|
||||
|
||||
return false;
|
||||
}
|
Reference in New Issue
Block a user