#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Instruction.h"
-#include "llvm/iMemory.h"
-#include "llvm/iTerminators.h"
-#include "llvm/iPHINode.h"
-#include "llvm/iOther.h"
+#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/SymbolTable.h"
#include "llvm/Assembly/Writer.h"
public:
/// If you'd like to deal with a function instead of just a module, use
/// this method to get its data into the SlotMachine.
- void incorporateFunction(const Function *F) { TheFunction = F; }
+ void incorporateFunction(const Function *F) {
+ TheFunction = F;
+ FunctionProcessed = false;
+ }
/// After calling incorporateFunction, use this method to remove the
/// most recently incorporated function from the SlotMachine. This
/// @brief The function for which we are holding slot numbers
const Function* TheFunction;
+ bool FunctionProcessed;
/// @brief The TypePlanes map for the module level data
TypedPlanes mMap;
Result += "]";
break;
}
+ case Type::PackedTyID: {
+ const PackedType *PTy = cast<PackedType>(Ty);
+ Result += "<" + utostr(PTy->getNumElements()) + " x ";
+ calcTypeName(PTy->getElementType(), TypeStack, TypeNames, Result);
+ Result += ">";
+ break;
+ }
case Type::OpaqueTyID:
Result += "opaque";
break;
}
Out << " }";
+ } else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(CV)) {
+ const Type *ETy = CP->getType()->getElementType();
+ assert(CP->getNumOperands() > 0 &&
+ "Number of operands for a PackedConst must be > 0");
+ Out << '<';
+ Out << ' ';
+ printTypeInt(Out, ETy, TypeTable);
+ WriteAsOperandInternal(Out, CP->getOperand(0),
+ PrintName, TypeTable, Machine);
+ for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
+ Out << ", ";
+ printTypeInt(Out, ETy, TypeTable);
+ WriteAsOperandInternal(Out, CP->getOperand(i), PrintName,
+ TypeTable, Machine);
+ }
+ Out << " >";
} else if (isa<ConstantPointerNull>(CV)) {
Out << "null";
} else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
Out << '[' << ATy->getNumElements() << " x ";
printType(ATy->getElementType()) << ']';
- } else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) {
+ } else if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) {
+ Out << '<' << PTy->getNumElements() << " x ";
+ printType(PTy->getElementType()) << '>';
+ }
+ else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) {
Out << "opaque";
} else {
if (!Ty->isPrimitiveType())
SlotMachine::SlotMachine(const Module *M)
: TheModule(M) ///< Saved for lazy initialization.
, TheFunction(0)
+ , FunctionProcessed(false)
, mMap()
, mTypes()
, fMap()
SlotMachine::SlotMachine(const Function *F )
: TheModule( F ? F->getParent() : 0 ) ///< Saved for lazy initialization
, TheFunction(F) ///< Saved for lazy initialization
+ , FunctionProcessed(false)
, mMap()
, mTypes()
, fMap()
processModule();
TheModule = 0; ///< Prevent re-processing next time we're called.
}
- if ( TheFunction ) {
+ if ( TheFunction && ! FunctionProcessed) {
processFunction();
}
}
}
}
+ FunctionProcessed = true;
+
SC_DEBUG("end processFunction!\n");
}
fMap.clear(); // Simply discard the function level map
fTypes.clear();
TheFunction = 0;
+ FunctionProcessed = false;
SC_DEBUG("end purgeFunction!\n");
}