//----------------------------------------------------------------------
template<class _NodeType>
-class ScheduleIterator: public std::forward_iterator<_NodeType, ptrdiff_t> {
+class ScheduleIterator : public forward_iterator<_NodeType, ptrdiff_t> {
private:
unsigned cycleNum;
unsigned slotNum;
{
}
-void SchedGraphEdge::dump(int indent=0) const {
+void SchedGraphEdge::dump(int indent) const {
cerr << std::string(indent*2, ' ') << *this;
}
deleter<SchedGraphEdge>);
}
-void SchedGraphNode::dump(int indent=0) const {
+void SchedGraphNode::dump(int indent) const {
cerr << std::string(indent*2, ' ') << *this;
}
// for <const SchedGraphNode, SchedGraphNode::const_iterator>.
//
template <class _NodeType, class _EdgeType, class _EdgeIter>
-class SGPredIterator: public std::bidirectional_iterator<_NodeType, ptrdiff_t> {
+class SGPredIterator: public bidirectional_iterator<_NodeType, ptrdiff_t> {
protected:
_EdgeIter oi;
public:
};
template <class _NodeType, class _EdgeType, class _EdgeIter>
-class SGSuccIterator: public std::bidirectional_iterator<_NodeType, ptrdiff_t> {
+class SGSuccIterator : public bidirectional_iterator<_NodeType, ptrdiff_t> {
protected:
_EdgeIter oi;
public:
MachineCodeForMethod::computeOffsetforLocalVar(const TargetMachine& target,
const Value* val,
unsigned int& getPaddedSize,
- unsigned int sizeToUse = 0)
+ unsigned int sizeToUse)
{
bool growUp;
int firstOffset =target.getFrameInfo().getFirstAutomaticVarOffset(*this,
int
MachineCodeForMethod::allocateLocalVar(const TargetMachine& target,
const Value* val,
- unsigned int sizeToUse = 0)
+ unsigned int sizeToUse)
{
assert(! automaticVarsAreaFrozen &&
"Size of auto vars area has been used to compute an offset so "
MachineInstr::SetMachineOperandVal(unsigned int i,
MachineOperand::MachineOperandType opType,
Value* _val,
- bool isdef=false,
- bool isDefAndUse=false)
+ bool isdef,
+ bool isDefAndUse)
{
assert(i < operands.size());
operands[i].Initialize(opType, _val);
void
MachineInstr::SetMachineOperandReg(unsigned int i,
int regNum,
- bool isdef=false,
- bool isDefAndUse=false,
- bool isCCReg=false)
+ bool isdef,
+ bool isDefAndUse,
+ bool isCCReg)
{
assert(i < operands.size());
operands[i].InitializeReg(regNum, isCCReg);
}
void cl::ParseCommandLineOptions(int &argc, char **argv,
- const char *Overview = 0) {
+ const char *Overview) {
assert((!getOpts().empty() || !getPositionalOpts().empty()) &&
"No options specified, or ParseCommandLineOptions called more"
" than once!");
// Option Base class implementation
//
-bool Option::error(string Message, const char *ArgName = 0) {
+bool Option::error(string Message, const char *ArgName) {
if (ArgName == 0) ArgName = ArgStr;
if (ArgName[0] == 0)
cerr << HelpStr; // Be nice for positional arguments
#include "Support/CommandLine.h"
#include <dlfcn.h>
#include <link.h>
+#include <iostream>
namespace {
struct PluginLoader {
}
// This causes operator= above to be invoked for every -load option.
-static cl::opt<PluginLoader, false, cl::parser<string> >
+static cl::opt<PluginLoader, false, cl::parser<std::string> >
LoadOpt("load", cl::ZeroOrMore, cl::value_desc("plugin.so"),
cl::desc("Load the specified plugin"));
//----------------------------------------------------------------------
template<class _NodeType>
-class ScheduleIterator: public std::forward_iterator<_NodeType, ptrdiff_t> {
+class ScheduleIterator : public forward_iterator<_NodeType, ptrdiff_t> {
private:
unsigned cycleNum;
unsigned slotNum;
{
}
-void SchedGraphEdge::dump(int indent=0) const {
+void SchedGraphEdge::dump(int indent) const {
cerr << std::string(indent*2, ' ') << *this;
}
deleter<SchedGraphEdge>);
}
-void SchedGraphNode::dump(int indent=0) const {
+void SchedGraphNode::dump(int indent) const {
cerr << std::string(indent*2, ' ') << *this;
}
// for <const SchedGraphNode, SchedGraphNode::const_iterator>.
//
template <class _NodeType, class _EdgeType, class _EdgeIter>
-class SGPredIterator: public std::bidirectional_iterator<_NodeType, ptrdiff_t> {
+class SGPredIterator: public bidirectional_iterator<_NodeType, ptrdiff_t> {
protected:
_EdgeIter oi;
public:
};
template <class _NodeType, class _EdgeType, class _EdgeIter>
-class SGSuccIterator: public std::bidirectional_iterator<_NodeType, ptrdiff_t> {
+class SGSuccIterator : public bidirectional_iterator<_NodeType, ptrdiff_t> {
protected:
_EdgeIter oi;
public:
//===----------------------------------------------------------------------===//
TargetData::TargetData(const std::string &TargetName,
- unsigned char IntRegSize = 8, unsigned char PtrSize = 8,
- unsigned char PtrAl = 8, unsigned char DoubleAl = 8,
- unsigned char FloatAl = 4, unsigned char LongAl = 8,
- unsigned char IntAl = 4, unsigned char ShortAl = 2,
- unsigned char ByteAl = 1)
+ unsigned char IntRegSize, unsigned char PtrSize,
+ unsigned char PtrAl, unsigned char DoubleAl,
+ unsigned char FloatAl, unsigned char LongAl,
+ unsigned char IntAl, unsigned char ShortAl,
+ unsigned char ByteAl)
: AID(AnnotationManager::getID("TargetData::" + TargetName)) {
AnnotationManager::registerAnnotationFactory(AID, TypeAnFactory, this);
//
void MutateStructTypes::AdjustIndices(const CompositeType *OldTy,
vector<Value*> &Idx,
- unsigned i = 0) {
+ unsigned i) {
assert(i < Idx.size() && "i out of range!");
const CompositeType *NewCT = cast<CompositeType>(ConvertType(OldTy));
if (NewCT == OldTy) return; // No adjustment unless type changes
//
Pass *createPoolAllocatePass() {
assert(0 && "Pool allocator disabled!");
+ return 0;
//return new PoolAllocate();
}
namespace {
class Reassociate : public FunctionPass {
- map<BasicBlock*, unsigned> RankMap;
+ std::map<BasicBlock*, unsigned> RankMap;
public:
bool runOnFunction(Function &F);
//
const Type *getStructOffsetType(const Type *Ty, unsigned &Offset,
std::vector<Value*> &Indices,
- bool StopEarly = true) {
+ bool StopEarly) {
if (Offset == 0 && StopEarly && !Indices.empty())
return Ty; // Return the leaf type
//
const Type *ConvertableToGEP(const Type *Ty, Value *OffsetVal,
std::vector<Value*> &Indices,
- BasicBlock::iterator *BI = 0) {
+ BasicBlock::iterator *BI) {
const CompositeType *CompTy = dyn_cast<CompositeType>(Ty);
if (CompTy == 0) return 0;
}
void cl::ParseCommandLineOptions(int &argc, char **argv,
- const char *Overview = 0) {
+ const char *Overview) {
assert((!getOpts().empty() || !getPositionalOpts().empty()) &&
"No options specified, or ParseCommandLineOptions called more"
" than once!");
// Option Base class implementation
//
-bool Option::error(string Message, const char *ArgName = 0) {
+bool Option::error(string Message, const char *ArgName) {
if (ArgName == 0) ArgName = ArgStr;
if (ArgName[0] == 0)
cerr << HelpStr; // Be nice for positional arguments
#include "Support/CommandLine.h"
#include <dlfcn.h>
#include <link.h>
+#include <iostream>
namespace {
struct PluginLoader {
}
// This causes operator= above to be invoked for every -load option.
-static cl::opt<PluginLoader, false, cl::parser<string> >
+static cl::opt<PluginLoader, false, cl::parser<std::string> >
LoadOpt("load", cl::ZeroOrMore, cl::value_desc("plugin.so"),
cl::desc("Load the specified plugin"));