//===-- TargetLowering.cpp - Implement the TargetLowering class -----------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This implements the TargetLowering class.
// Everything defaults to one.
for (unsigned i = 0; i != MVT::LAST_VALUETYPE; ++i)
NumElementsForVT[i] = 1;
-
+
// Find the largest integer register class.
unsigned LargestIntReg = MVT::i128;
for (; RegClassForVT[LargestIntReg] == 0; --LargestIntReg)
TransformToType, ValueTypeActions);
else
TransformToType[(MVT::ValueType)IntReg] = (MVT::ValueType)IntReg;
-
+
// If the target does not have native support for F32, promote it to F64.
if (!hasNativeSupportFor(MVT::f32))
SetValueTypeAction(MVT::f32, Promote, *this,
//===-- Intercept.cpp - System function interception routines -------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// If a function call occurs to an external function, the JIT is designed to use
#if defined(__linux__)
#if defined(HAVE_SYS_STAT_H)
#include <sys/stat.h>
-#endif
+#endif
void *FunctionPointers[] = {
(void *) stat,
(void *) fstat,
}
//===----------------------------------------------------------------------===//
-//
+//
/// getPointerToNamedFunction - This method returns the address of the specified
-/// function by using the dynamic loader interface. As such it is only useful
+/// function by using the dynamic loader interface. As such it is only useful
/// for resolving library symbols, not code generated symbols.
///
void *JIT::getPointerToNamedFunction(const std::string &Name) {
//===-- JIT.cpp - LLVM Just in Time Compiler ------------------------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This tool implements a just-in-time compiler for LLVM, allowing direct
// Initialize MCE
MCE = createEmitter(*this);
-
+
// Add target data
PM.add(new TargetData(TM.getTargetData()));
if (RetTy == Type::IntTy || RetTy == Type::UIntTy || RetTy == Type::VoidTy) {
switch (ArgValues.size()) {
case 3:
- if ((FTy->getParamType(0) == Type::IntTy ||
+ if ((FTy->getParamType(0) == Type::IntTy ||
FTy->getParamType(0) == Type::UIntTy) &&
isa<PointerType>(FTy->getParamType(1)) &&
isa<PointerType>(FTy->getParamType(2))) {
}
break;
case 2:
- if ((FTy->getParamType(0) == Type::IntTy ||
+ if ((FTy->getParamType(0) == Type::IntTy ||
FTy->getParamType(0) == Type::UIntTy) &&
isa<PointerType>(FTy->getParamType(1))) {
int (*PF)(int, char **) = (int(*)(int, char **))FPtr;
break;
case 1:
if (FTy->getNumParams() == 1 &&
- (FTy->getParamType(0) == Type::IntTy ||
+ (FTy->getParamType(0) == Type::IntTy ||
FTy->getParamType(0) == Type::UIntTy)) {
GenericValue rv;
int (*PF)(int) = (int(*)(int))FPtr;
return Addr; // Check if function already code gen'd
// Make sure we read in the function if it exists in this Module
- if (F->hasNotBeenReadFromBytecode())
+ if (F->hasNotBeenReadFromBytecode())
try {
MP->materializeFunction(F);
} catch ( std::string& errmsg ) {
//===-- JIT.h - Class definition for the JIT --------------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines the top-level JIT data structure.
class JIT : public ExecutionEngine {
TargetMachine &TM; // The current target we are compiling to
TargetJITInfo &TJI; // The JITInfo for the target we are compiling to
-
+
FunctionPassManager PM; // Passes to compile a function
MachineCodeEmitter *MCE; // MCE object
// CompilationCallback - Invoked the first time that a call site is found,
// which causes lazy compilation of the target function.
- //
+ //
static void CompilationCallback();
/// getPointerToFunction - This returns the address of the specified function,
//===-- JITEmitter.cpp - Write machine code to executable memory ----------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines a MachineCodeEmitter object that is used by the JIT to
public:
JITMemoryManager();
~JITMemoryManager();
-
+
inline unsigned char *allocateStub(unsigned StubSize);
inline unsigned char *allocateConstant(unsigned ConstantSize,
unsigned Alignment);
void *Actual = (void*)LazyResolverFn;
if (F->isExternal() && F->hasExternalLinkage())
Actual = TheJIT->getPointerToFunction(F);
-
+
// Otherwise, codegen a new stub. For now, the stub will call the lazy
// resolver function.
Stub = TheJIT->getJITInfo().emitFunctionStub(Actual, MCE);
/// it if necessary, then returns the resultant function pointer.
void *JITResolver::JITCompilerFn(void *Stub) {
JITResolver &JR = getJITResolver();
-
+
// The address given to us for the stub may not be exactly right, it might be
// a little bit after the stub. As such, use upper_bound to find it.
std::map<void*, Function*>::iterator I =
void *ResultPtr;
if (MR.isString()) {
ResultPtr = TheJIT->getPointerToNamedFunction(MR.getString());
-
+
// If the target REALLY wants a stub for this function, emit it now.
if (!MR.doesntNeedFunctionStub())
ResultPtr = getJITResolver(this).getExternalFunctionStub(ResultPtr);
//===-- TargetSelect.cpp - Target Chooser Code ----------------------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This just asks the TargetMachineRegistry for the appropriate JIT to use, and
//===- lib/Linker/LinkArchives.cpp - Link LLVM objects and libraries ------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file contains routines to handle linking together LLVM bytecode files,
/// GetAllDefinedSymbols - Modifies its parameter DefinedSymbols to contain the
/// name of each externally-visible symbol defined in M.
///
-static void
+static void
GetAllDefinedSymbols(Module *M, std::set<std::string> &DefinedSymbols) {
for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
if (I->hasName() && !I->isExternal() && !I->hasInternalLinkage())
Function *Main = M->getMainFunction();
if (Main == 0 || Main->isExternal())
UndefinedSymbols.insert("main");
-
+
for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
if (I->hasName()) {
if (I->isExternal())
else if (!I->hasInternalLinkage())
DefinedSymbols.insert(I->getName());
}
-
+
// Prune out any defined symbols from the undefined symbols set...
for (std::set<std::string>::iterator I = UndefinedSymbols.begin();
I != UndefinedSymbols.end(); )
/// Return Value:
/// TRUE - An error occurred.
/// FALSE - No errors.
-bool
+bool
Linker::LinkInArchive(const sys::Path &Filename) {
// Make sure this is an archive file we're dealing with
// no reason to link in any archive files.
std::set<std::string> UndefinedSymbols;
GetAllUndefinedSymbols(Composite, UndefinedSymbols);
-
+
if (UndefinedSymbols.empty()) {
- verbose("No symbols undefined, skipping library '" +
+ verbose("No symbols undefined, skipping library '" +
Filename.toString() + "'");
return false; // No need to link anything in!
}
Archive* arch = AutoArch.get();
if (!arch)
- return error("Cannot read archive '" + Filename.toString() +
+ return error("Cannot read archive '" + Filename.toString() +
"': " + ErrMsg);
// Save a set of symbols that are not defined by the archive. Since we're
std::set<std::string> NotDefinedByArchive;
// While we are linking in object files, loop.
- while (true) {
+ while (true) {
// Find the modules we need to link into the target module
std::set<ModuleProvider*> Modules;
arch->findModulesDefiningSymbols(UndefinedSymbols, Modules);
- // If we didn't find any more modules to link this time, we are done
+ // If we didn't find any more modules to link this time, we are done
// searching this archive.
if (Modules.empty())
break;
// Link it in
if (LinkInModule(aModule))
- return error("Cannot link in module '" +
+ return error("Cannot link in module '" +
aModule->getModuleIdentifier() + "': " + Error);
}
GetAllUndefinedSymbols(Composite, UndefinedSymbols);
// At this point we have two sets of undefined symbols: UndefinedSymbols
- // which holds the undefined symbols from all the modules, and
+ // which holds the undefined symbols from all the modules, and
// NotDefinedByArchive which holds symbols we know the archive doesn't
// define. There's no point searching for symbols that we won't find in the
// archive so we subtract these sets.
set_subtract(UndefinedSymbols, NotDefinedByArchive);
-
+
// If there's no symbols left, no point in continuing to search the
// archive.
if (UndefinedSymbols.empty())
break;
}
-
+
return false;
}
//===- lib/Linker/LinkItems.cpp - Link LLVM objects and libraries ---------===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file contains routines to handle linking together LLVM bytecode files,
bool
Linker::LinkInItems(const ItemList& Items) {
// For each linkage item ...
- for (ItemList::const_iterator I = Items.begin(), E = Items.end();
+ for (ItemList::const_iterator I = Items.begin(), E = Items.end();
I != E; ++I) {
if (I->second) {
// Link in the library suggested.
// that module should also be aggregated with duplicates eliminated. This is
// now the time to process the dependent libraries to resolve any remaining
// symbols.
- for (Module::lib_iterator I = Composite->lib_begin(),
+ for (Module::lib_iterator I = Composite->lib_begin(),
E = Composite->lib_end(); I != E; ++I)
if(LinkInLibrary(*I))
return true;
// now the time to process the dependent libraries to resolve any remaining
// symbols.
const Module::LibraryListType& DepLibs = Composite->getLibraries();
- for (Module::LibraryListType::const_iterator I = DepLibs.begin(),
- E = DepLibs.end(); I != E; ++I)
- if (LinkInLibrary(*I))
+ for (Module::LibraryListType::const_iterator I = DepLibs.begin(),
+ E = DepLibs.end(); I != E; ++I)
+ if (LinkInLibrary(*I))
return true;
return false;
verbose("Linking bytecode file '" + File.toString() + "'");
std::auto_ptr<Module> M(LoadObject(File));
- if (M.get() == 0)
+ if (M.get() == 0)
return error("Cannot load file '" + File.toString() + "'" + Error);
if (LinkInModule(M.get()))
return error("Cannot link file '" + File.toString() + "'" + Error);
//===- lib/Linker/LinkModules.cpp - Module Linker Implementation ----------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the LLVM module linker.
const Type *SrcTyT = SrcTy.get();
const Type *DestTyT = DestTy.get();
if (DestTyT == SrcTyT) return false; // If already equal, noop
-
+
// If we found our opaque type, resolve it now!
if (isa<OpaqueType>(DestTyT) || isa<OpaqueType>(SrcTyT))
return ResolveTypes(DestTyT, SrcTyT, DestST, Name);
-
+
// Two types cannot be resolved together if they are of different primitive
// type. For example, we cannot resolve an int to a float.
if (DestTyT->getTypeID() != SrcTyT->getTypeID()) return true;
return false;
}
case Type::StructTyID: {
- if (getST(DestTy)->getNumContainedTypes() !=
+ if (getST(DestTy)->getNumContainedTypes() !=
getST(SrcTy)->getNumContainedTypes()) return 1;
for (unsigned i = 0, e = getST(DestTy)->getNumContainedTypes(); i != e; ++i)
if (RecursiveResolveTypesI(getST(DestTy)->getContainedType(i),
return Result;
}
default: assert(0 && "Unexpected type!"); return true;
- }
+ }
}
static bool RecursiveResolveTypes(const PATypeHolder &DestTy,
if (!RecursiveResolveTypes(T2, T1, DestST, Name)) {
// We are making progress!
DelayedTypesToResolve.erase(DelayedTypesToResolve.begin()+i);
-
+
// Go back to the main loop, perhaps we can resolve directly by name
// now...
break;
} else {
assert(Dest->hasExternalLinkage() && Src->hasExternalLinkage() &&
"Unexpected linkage type!");
- return Error(Err, "Linking globals named '" + Src->getName() +
+ return Error(Err, "Linking globals named '" + Src->getName() +
"': symbol multiply defined!");
}
return false;
// We will need a module level symbol table if the src module has a module
// level symbol table...
SymbolTable *ST = (SymbolTable*)&Dest->getSymbolTable();
-
+
// Loop over all of the globals in the src module, mapping them over as we go
for (Module::global_iterator I = Src->global_begin(), E = Src->global_end(); I != E; ++I) {
GlobalVariable *SGV = I;
Constant *SInit =
cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap));
- GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[SGV]);
+ GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[SGV]);
if (DGV->hasInitializer()) {
if (SGV->hasExternalLinkage()) {
if (DGV->getInitializer() != SInit)
- return Error(Err, "Global Variable Collision on '" +
+ return Error(Err, "Global Variable Collision on '" +
ToStr(SGV->getType(), Src) +"':%"+SGV->getName()+
" - Global variables have different initializers");
} else if (DGV->hasLinkOnceLinkage() || DGV->hasWeakLinkage()) {
std::map<std::string, GlobalValue*> &GlobalsByName,
std::string *Err) {
SymbolTable *ST = (SymbolTable*)&Dest->getSymbolTable();
-
+
// Loop over all of the functions in the src module, mapping them over as we
// go
for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) {
"' have different linkage specifiers!");
} else if (SF->hasExternalLinkage()) {
// The function is defined in both modules!!
- return Error(Err, "Function '" +
- ToStr(SF->getFunctionType(), Src) + "':\"" +
+ return Error(Err, "Function '" +
+ ToStr(SF->getFunctionType(), Src) + "':\"" +
SF->getName() + "\" - Function is already defined!");
} else {
assert(0 && "Unknown linkage configuration found!");
std::multimap<std::string, GlobalVariable *> &AppendingVars,
std::string *ErrorMsg) {
if (AppendingVars.empty()) return false; // Nothing to do.
-
+
// Loop over the multimap of appending vars, processing any variables with the
// same name, forming a new appending global variable with both of the
// initializers merged together, then rewrite references to the old variables
GlobalVariable *G1 = First->second, *G2 = Second->second;
const ArrayType *T1 = cast<ArrayType>(G1->getType()->getElementType());
const ArrayType *T2 = cast<ArrayType>(G2->getType()->getElementType());
-
+
// Check to see that they two arrays agree on type...
if (T1->getElementType() != T2->getElementType())
return Error(ErrorMsg,
// error occurs, true is returned and ErrorMsg (if not null) is set to indicate
// the problem. Upon failure, the Dest module could be in a modified state, and
// shouldn't be relied on to be consistent.
-bool
+bool
Linker::LinkModules(Module *Dest, Module *Src, std::string *ErrorMsg) {
assert(Dest != 0 && "Invalid Destination module");
assert(Src != 0 && "Invalid Source Module");
if (!Src->getTargetTriple().empty() &&
Dest->getTargetTriple() != Src->getTargetTriple())
std::cerr << "WARNING: Linking two modules of different target triples!\n";
-
+
// Update the destination module's dependent libraries list with the libraries
// from the source module. There's no opportunity for duplicates here as the
// Module ensures that duplicate insertions are discarded.
//===- lib/Linker/Linker.cpp - Basic Linker functionality ----------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file contains basic Linker functionality that all usages will need.
delete Composite;
}
-bool
+bool
Linker::error(const std::string& message) {
Error = message;
if (!(Flags&QuietErrors)) {
}
// LoadObject - Read in and parse the bytecode file named by FN and return the
-// module it contains (wrapped in an auto_ptr), or auto_ptr<Module>() and set
+// module it contains (wrapped in an auto_ptr), or auto_ptr<Module>() and set
// Error if an error occurs.
-std::auto_ptr<Module>
+std::auto_ptr<Module>
Linker::LoadObject(const sys::Path &FN) {
std::string ParseErrorMessage;
Module *Result = ParseBytecodeFile(FN.toString(), &ParseErrorMessage);
- if (Result)
+ if (Result)
return std::auto_ptr<Module>(Result);
Error = "Bytecode file '" + FN.toString() + "' could not be loaded";
- if (ParseErrorMessage.size())
+ if (ParseErrorMessage.size())
Error += ": " + ParseErrorMessage;
return std::auto_ptr<Module>();
}
-// IsLibrary - Determine if "Name" is a library in "Directory". Return
+// IsLibrary - Determine if "Name" is a library in "Directory". Return
// a non-empty sys::Path if its found, an empty one otherwise.
-static inline sys::Path IsLibrary(const std::string& Name,
+static inline sys::Path IsLibrary(const std::string& Name,
const sys::Path& Directory) {
assert(Directory.isDirectory() && "Need to specify a directory");
/// FindLib - Try to convert Filename into the name of a file that we can open,
/// if it does not already name a file we can open, by first trying to open
/// Filename, then libFilename.[suffix] for each of a set of several common
-/// library suffixes, in each of the directories in LibPaths. Returns an empty
+/// library suffixes, in each of the directories in LibPaths. Returns an empty
/// Path if no matching file can be found.
///
-sys::Path
-Linker::FindLib(const std::string &Filename)
+sys::Path
+Linker::FindLib(const std::string &Filename)
{
// Determine if the pathname can be found as it stands.
sys::Path FilePath(Filename);
- if (FilePath.readable() &&
+ if (FilePath.readable() &&
(FilePath.isArchive() || FilePath.isDynamicLibrary()))
return FilePath;
//===-- Annotation.cpp - Implement the Annotation Classes -----------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the AnnotationManager class.
void *Data) {
AnnotationID Result(getID(Name));
registerAnnotationFactory(Result, Fact, Data);
- return Result;
+ return Result;
}
// getName - This function is especially slow, but that's okay because it should
}
// registerAnnotationFactory - This method is used to register a callback
-// function used to create an annotation on demand if it is needed by the
+// function used to create an annotation on demand if it is needed by the
// Annotable::findOrCreateAnnotation method.
//
void AnnotationManager::registerAnnotationFactory(AnnotationID ID, AnnFactory F,
// createAnnotation - Create an annotation of the specified ID for the
// specified object, using a register annotation creation function.
//
-Annotation *AnnotationManager::createAnnotation(AnnotationID ID,
+Annotation *AnnotationManager::createAnnotation(AnnotationID ID,
const Annotable *Obj) {
FactMapType::iterator I = getFactMap().find(ID.ID);
if (I == getFactMap().end()) return 0;
//===-- CommandLine.cpp - Command line parser implementation --------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This class implements a command line argument processor that is useful when
static void AddArgument(const char *ArgName, Option *Opt) {
if (getOption(ArgName)) {
- std::cerr << ProgramName << ": CommandLine Error: Argument '"
+ std::cerr << ProgramName << ": CommandLine Error: Argument '"
<< ArgName << "' defined more than once!\n";
} else {
// Add argument to the argument map!
// RemoveArgument - It's possible that the argument is no longer in the map if
// options have already been processed and the map has been deleted!
-//
+//
static void RemoveArgument(const char *ArgName, Option *Opt) {
if(getOpts().empty()) return;
break;
case ValueDisallowed:
if (*Value != 0)
- return Handler->error(" does not allow a value! '" +
+ return Handler->error(" does not allow a value! '" +
std::string(Value) + "' specified.");
break;
- case ValueOptional:
+ case ValueOptional:
break;
- default:
- std::cerr << ProgramName
- << ": Bad ValueMask flag! CommandLine usage error:"
- << Handler->getValueExpectedFlag() << "\n";
+ default:
+ std::cerr << ProgramName
+ << ": Bad ValueMask flag! CommandLine usage error:"
+ << Handler->getValueExpectedFlag() << "\n";
abort();
break;
}
return Handler->addOccurrence(i, ArgName, Value);
}
-static bool ProvidePositionalOption(Option *Handler, const std::string &Arg,
+static bool ProvidePositionalOption(Option *Handler, const std::string &Arg,
int i) {
int Dummy = i;
return ProvideOption(Handler, Handler->ArgStr, Arg.c_str(), 0, 0, Dummy);
//
static Option *getOptionPred(std::string Name, unsigned &Length,
bool (*Pred)(const Option*)) {
-
+
Option *Op = getOption(Name);
if (Op && Pred(Op)) {
Length = Name.length();
// Check args.
assert(progName && "Program name not specified");
assert(envVar && "Environment variable name missing");
-
+
// Get the environment variable they want us to parse options out of.
const char *envValue = getenv (envVar);
if (!envValue)
/// that as well.
static Option *LookupOption(const char *&Arg, const char *&Value) {
while (*Arg == '-') ++Arg; // Eat leading dashes
-
+
const char *ArgEnd = Arg;
while (*ArgEnd && *ArgEnd != '=')
++ArgEnd; // Scan till end of argument name...
Value = ArgEnd;
if (*Value) // If we have an equals sign...
++Value; // Advance to value...
-
+
if (*Arg == 0) return 0;
// Look up the option.
// All of the positional arguments have been fulfulled, give the rest to
// the consume after option... if it's specified...
//
- if (PositionalVals.size() >= NumPositionalRequired &&
+ if (PositionalVals.size() >= NumPositionalRequired &&
ConsumeAfterOpt != 0) {
for (++i; i < argc; ++i)
PositionalVals.push_back(std::make_pair(argv[i],i));
if (RealName.size() > 1) {
unsigned Length = 0;
Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping);
-
+
// If the option is a prefixed option, then the value is simply the
// rest of the name... so fall through to later processing, by
// setting up the argument name flags and value fields.
} else if (PGOpt) {
// This must be a grouped option... handle them now.
assert(isGrouping(PGOpt) && "Broken getOptionPred!");
-
+
do {
// Move current arg name out of RealName into RealArgName...
std::string RealArgName(RealName.begin(),
RealName.begin() + Length);
RealName.erase(RealName.begin(), RealName.begin() + Length);
-
+
// Because ValueRequired is an invalid flag for grouped arguments,
// we don't need to pass argc/argv in...
//
int Dummy;
ErrorParsing |= ProvideOption(PGOpt, RealArgName.c_str(),
"", 0, 0, Dummy);
-
+
// Get the next grouping option...
PGOpt = getOptionPred(RealName, Length, isGrouping);
} while (PGOpt && Length != RealName.size());
-
+
Handler = PGOpt; // Ate all of the options.
}
}
// active one...
if (Handler->getFormattingFlag() == cl::Positional)
ActivePositionalArg = Handler;
- else
+ else
ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i);
}
// Check and handle positional arguments now...
if (NumPositionalRequired > PositionalVals.size()) {
- std::cerr << ProgramName
+ std::cerr << ProgramName
<< ": Not enough positional command line arguments specified!\n"
<< "Must specify at least " << NumPositionalRequired
<< " positional arguments: See: " << argv[0] << " --help\n";
unsigned ValNo = 0, NumVals = PositionalVals.size();
for (unsigned i = 0, e = PositionalOpts.size(); i != e; ++i) {
if (RequiresValue(PositionalOpts[i])) {
- ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first,
+ ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first,
PositionalVals[ValNo].second);
ValNo++;
--NumPositionalRequired; // We fulfilled our duty...
PositionalVals[ValNo].second);
ValNo++;
}
-
+
// Handle over all of the rest of the arguments to the
// cl::ConsumeAfter command line option...
for (; ValNo != PositionalVals.size(); ++ValNo)
}
// Loop over args and make sure all required args are specified!
- for (std::map<std::string, Option*>::iterator I = Opts.begin(),
+ for (std::map<std::string, Option*>::iterator I = Opts.begin(),
E = Opts.end(); I != E; ++I) {
switch (I->second->getNumOccurrencesFlag()) {
case Required:
return Len + 6;
}
-// printOptionInfo - Print out information about this option. The
+// printOptionInfo - Print out information about this option. The
// to-be-maintained width is specified.
//
void basic_parser_impl::printOptionInfo(const Option &O,
//
bool parser<bool>::parse(Option &O, const char *ArgName,
const std::string &Arg, bool &Value) {
- if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
+ if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
Arg == "1") {
Value = true;
} else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") {
const std::string &Arg, int &Value) {
char *End;
Value = (int)strtol(Arg.c_str(), &End, 0);
- if (*End != 0)
+ if (*End != 0)
return O.error(": '" + Arg + "' value invalid for integer argument!");
return false;
}
const char *ArgStart = Arg.c_str();
char *End;
Value = strtod(ArgStart, &End);
- if (*End != 0)
+ if (*End != 0)
return O.error(": '" +Arg+ "' value invalid for floating point argument!");
return false;
}
}
}
-// printOptionInfo - Print out information about this option. The
+// printOptionInfo - Print out information about this option. The
// to-be-maintained width is specified.
//
void generic_parser_base::printOptionInfo(const Option &O,
}
} else {
if (O.HelpStr[0])
- std::cerr << " " << O.HelpStr << "\n";
+ std::cerr << " " << O.HelpStr << "\n";
for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
unsigned L = std::strlen(getOption(i));
std::cerr << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ')
copy(getOpts().begin(), getOpts().end(), std::back_inserter(Options));
// Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden
- Options.erase(std::remove_if(Options.begin(), Options.end(),
+ Options.erase(std::remove_if(Options.begin(), Options.end(),
std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)),
Options.end());
public:
void operator=(bool OptionWasSpecified) {
if (OptionWasSpecified) {
- std::cerr << "Low Level Virtual Machine (" << PACKAGE_NAME << ") "
+ std::cerr << "Low Level Virtual Machine (" << PACKAGE_NAME << ") "
<< PACKAGE_VERSION << " (see http://llvm.cs.uiuc.edu/)\n";
getOpts().clear(); // Don't bother making option dtors remove from map.
exit(1);
HelpPrinter NormalPrinter(false);
HelpPrinter HiddenPrinter(true);
-cl::opt<HelpPrinter, true, parser<bool> >
+cl::opt<HelpPrinter, true, parser<bool> >
HOp("help", cl::desc("display available options (--help-hidden for more)"),
cl::location(NormalPrinter), cl::ValueDisallowed);
// Define the --version option that prints out the LLVM version for the tool
VersionPrinter VersionPrinterInstance;
cl::opt<VersionPrinter, true, parser<bool> >
-VersOp("version", cl::desc("display the version"),
+VersOp("version", cl::desc("display the version"),
cl::location(VersionPrinterInstance), cl::ValueDisallowed);
// Utility function for printing the help message.
void cl::PrintHelpMessage() {
- // This looks weird, but it actually prints the help message. The
+ // This looks weird, but it actually prints the help message. The
// NormalPrinter variable is a HelpPrinter and the help gets printed when
// its operator= is invoked. That's because the "normal" usages of the
- // help printer is to be assigned true/false depending on whether the
+ // help printer is to be assigned true/false depending on whether the
// --help option was given or not. Since we're circumventing that we have
// to make it look like --help was given, so we assign true.
NormalPrinter = true;
//===- lib/Support/Compressor.cpp -------------------------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the llvm::Compressor class, an abstraction for memory
COMP_TYPE_BZIP2 = '2',
};
-static int getdata(char*& buffer, size_t &size,
+static int getdata(char*& buffer, size_t &size,
llvm::Compressor::OutputDataCallback* cb, void* context) {
buffer = 0;
size = 0;
return result;
}
-static int getdata_uns(char*& buffer, unsigned &size,
+static int getdata_uns(char*& buffer, unsigned &size,
llvm::Compressor::OutputDataCallback* cb, void* context) {
size_t SizeOut;
int Res = getdata(buffer, SizeOut, cb, context);
}
//===----------------------------------------------------------------------===//
-//=== NULLCOMP - a compression like set of routines that just copies data
+//=== NULLCOMP - a compression like set of routines that just copies data
//=== without doing any compression. This is provided so that if the
//=== configured environment doesn't have a compression library the
//=== program can still work, albeit using more data/memory.
/// This structure is only used when a bytecode file is compressed.
/// As bytecode is being decompressed, the memory buffer might need
-/// to be reallocated. The buffer allocation is handled in a callback
+/// to be reallocated. The buffer allocation is handled in a callback
/// and this structure is needed to retain information across calls
/// to the callback.
/// @brief An internal buffer object used for handling decompression
struct BufferContext {
char* buff;
size_t size;
- BufferContext(size_t compressedSize) {
+ BufferContext(size_t compressedSize) {
// Null to indicate malloc of a new block
- buff = 0;
+ buff = 0;
// Compute the initial length of the uncompression buffer. Note that this
// is twice the length of the compressed buffer and will be doubled again
- // in the callback for an initial allocation of 4x compressedSize. This
- // calculation is based on the typical compression ratio of bzip2 on LLVM
- // bytecode files which typically ranges in the 50%-75% range. Since we
- // typically get at least 50%, doubling is insufficient. By using a 4x
+ // in the callback for an initial allocation of 4x compressedSize. This
+ // calculation is based on the typical compression ratio of bzip2 on LLVM
+ // bytecode files which typically ranges in the 50%-75% range. Since we
+ // typically get at least 50%, doubling is insufficient. By using a 4x
// multiplier on the first allocation, we minimize the impact of having to
// copy the buffer on reallocation.
- size = compressedSize*2;
+ size = compressedSize*2;
}
/// trimTo - Reduce the size of the buffer down to the specified amount. This
/// This function handles allocation of the buffer used for decompression of
/// compressed bytecode files. It is called by Compressor::decompress which is
- /// called by BytecodeReader::ParseBytecode.
+ /// called by BytecodeReader::ParseBytecode.
static size_t callback(char*&buff, size_t &sz, void* ctxt){
// Case the context variable to our BufferContext
BufferContext* bc = reinterpret_cast<BufferContext*>(ctxt);
// Figure out what to return to the Compressor. If this is the first call,
// then bc->buff will be null. In this case we want to return the entire
// buffer because there was no previous allocation. Otherwise, when the
- // buffer is reallocated, we save the new base pointer in the
- // BufferContext.buff field but return the address of only the extension,
- // mid-way through the buffer (since its size was doubled). Furthermore,
+ // buffer is reallocated, we save the new base pointer in the
+ // BufferContext.buff field but return the address of only the extension,
+ // mid-way through the buffer (since its size was doubled). Furthermore,
// the sz result must be 1/2 the total size of the buffer.
if (bc->buff == 0 ) {
buff = bc->buff = new_buff;
}
};
-} // end anonymous namespace
+} // end anonymous namespace
namespace {
// This structure retains the context when compressing the bytecode file. The
// WriteCompressedData function below uses it to keep track of the previously
-// filled chunk of memory (which it writes) and how many bytes have been
+// filled chunk of memory (which it writes) and how many bytes have been
// written.
struct WriterContext {
// Initialize the context
- WriterContext(std::ostream*OS, size_t CS)
+ WriterContext(std::ostream*OS, size_t CS)
: chunk(0), sz(0), written(0), compSize(CS), Out(OS) {}
// Make sure we clean up memory
sz = 0;
}
- // This function is a callback used by the Compressor::compress function to
+ // This function is a callback used by the Compressor::compress function to
// allocate memory for the compression buffer. This function fulfills that
// responsibility but also writes the previous (now filled) buffer out to the
- // stream.
+ // stream.
static size_t callback(char*& buffer, size_t &size, void* context) {
// Cast the context to the structure it must point to.
WriterContext* ctxt = reinterpret_cast<WriterContext*>(context);
} // end anonymous namespace
// Compress in one of three ways
-size_t Compressor::compress(const char* in, size_t size,
+size_t Compressor::compress(const char* in, size_t size,
OutputDataCallback* cb, void* context) {
assert(in && "Can't compress null buffer");
assert(size && "Can't compress empty buffer");
return result;
}
-size_t
+size_t
Compressor::compressToStream(const char*in, size_t size, std::ostream& out) {
// Set up the context and writer
WriterContext ctxt(&out, size / 2);
return result;
}
-size_t
+size_t
Compressor::decompressToNewBuffer(const char* in, size_t size, char*&out) {
BufferContext bc(size);
size_t result = decompress(in,size,BufferContext::callback,(void*)&bc);
return result;
}
-size_t
+size_t
Compressor::decompressToStream(const char*in, size_t size, std::ostream& out){
// Set up the context and writer
WriterContext ctxt(&out,size / 2);
//===-- Debug.cpp - An easy way to add debug output to your code ----------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements a handle way of adding debugging information to your
//===- Support/FileUtilities.cpp - File System Utilities ------------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements a family of utility functions which are useful for doing
static bool isNumberChar(char C) {
switch (C) {
case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
+ case '5': case '6': case '7': case '8': case '9':
case '.': case '+': case '-':
case 'e':
case 'E': return true;
double AbsTolerance, double RelTolerance,
std::string *ErrorMsg) {
char *F1NumEnd, *F2NumEnd;
- double V1 = 0.0, V2 = 0.0;
+ double V1 = 0.0, V2 = 0.0;
// If one of the positions is at a space and the other isn't, chomp up 'til
// the end of the space.
return 1;
// Now its safe to mmap the files into memory becasue both files
- // have a non-zero size.
+ // have a non-zero size.
sys::MappedFile F1(FileA);
sys::MappedFile F2(FileB);
F1.map();
// If the files need padding, do so now.
PadFileIfNeeded(File1Start, File1End, F1P);
PadFileIfNeeded(File2Start, File2End, F2P);
-
+
bool CompareFailed = false;
while (1) {
// Scan for the end of file or next difference.
//===-- IsInf.cpp - Platform-independent wrapper around C99 isinf() -------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
#include "llvm/Config/config.h"
#define isinf(X) (!_finite(X))
#elif defined(_AIX) && defined(__GNUC__)
// GCC's fixincludes seems to be removing the isinf() declaration from the
-// system header /usr/include/math.h
+// system header /usr/include/math.h
# include <math.h>
static int isinf(double x) { return !finite(x) && x==x; }
#else
//===-- IsNAN.cpp ---------------------------------------------------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
-// Platform-independent wrapper around C99 isnan().
+// Platform-independent wrapper around C99 isnan().
//
//===----------------------------------------------------------------------===//
//===-- PluginLoader.cpp - Implement -load command line option ------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the -load <plugin> command line option handler.
//===-- SlowOperationInformer.cpp - Keep the user informed ----------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
-//
+//
// This file implements the SlowOperationInformer class for the LLVM debugger.
//
//===----------------------------------------------------------------------===//
//===-- Statistic.cpp - Easy way to expose stats information --------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the 'Statistic' class, which is designed to be an easy
// Figure out how long the biggest Value and Name fields are...
unsigned MaxNameLen = 0, MaxValLen = 0;
for (unsigned i = 0, e = AccumStats->size(); i != e; ++i) {
- MaxValLen = std::max(MaxValLen,
+ MaxValLen = std::max(MaxValLen,
(unsigned)(*AccumStats)[i].Value.length());
- MaxNameLen = std::max(MaxNameLen,
+ MaxNameLen = std::max(MaxNameLen,
(unsigned)std::strlen((*AccumStats)[i].Name));
}
//===-- StringExtras.cpp - Implement the StringExtras header --------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the StringExtras.h header
// Create the return token.
std::string Result = std::string(Source.begin()+Start, Source.begin()+End);
-
+
// Erase the token that we read in.
Source.erase(Source.begin(), Source.begin()+End);
-
+
return Result;
}
//===- SystemUtils.cpp - Utilities for low-level system tasks -------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file contains functions used to do a variety of low-level, often
#undef FindExecutable // needed on windows :(
sys::Path llvm::FindExecutable(const std::string &ExeName,
const std::string &ProgramPath) {
- // First check the directory that the calling program is in. We can do this
+ // First check the directory that the calling program is in. We can do this
// if ProgramPath contains at least one / character, indicating that it is a
// relative path to bugpoint itself.
sys::Path Result ( ProgramPath );
Result.elideFile();
if (!Result.isEmpty()) {
Result.appendFile(ExeName);
- if (Result.executable())
+ if (Result.executable())
return Result;
}
//===-- Timer.cpp - Interval Timing Support -------------------------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// Interval Timing implementation.
if (Total.getProcessTime())
printVal(getProcessTime(), Total.getProcessTime(), OS);
printVal(Elapsed, Total.Elapsed, OS);
-
+
OS << " ";
if (Total.MemUsed) {
{ // Scope to contain Total timer... don't allow total timer to drop us to
// zero timers...
Timer Total("TOTAL");
-
+
for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
Total.sum(TimersToPrint[i]);
-
+
// Print out timing header...
*OutStream << "===" << std::string(73, '-') << "===\n"
<< std::string(Padding, ' ') << Name << "\n"
if (Total.getPeakMem())
*OutStream << " -PeakMem-";
*OutStream << " --- Name ---\n";
-
+
// Loop through all of the timing data, printing it out...
for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
TimersToPrint[i].print(Total, *OutStream);
-
+
Total.print(Total, *OutStream);
*OutStream << std::endl; // Flush output
}
//===-- ToolRunner.cpp ----------------------------------------------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the interfaces described in the ToolRunner.h file.
redirects[0] = &StdInFile;
redirects[1] = &StdOutFile;
redirects[2] = &StdErrFile;
-
- return
+
+ return
sys::Program::ExecuteAndWait(ProgramPath, Args, 0, redirects, NumSeconds);
}
ToolArgs.clear ();
if (Args) { ToolArgs = *Args; }
}
-
+
virtual int ExecuteProgram(const std::string &Bytecode,
const std::vector<std::string> &Args,
const std::string &InputFile,
const std::string &OutputFile,
- const std::vector<std::string> &SharedLibs =
+ const std::vector<std::string> &SharedLibs =
std::vector<std::string>(),
unsigned Timeout = 0);
};
std::cerr << "\n";
);
return RunProgramWithTimeout(sys::Path(LLIPath), &LLIArgs[0],
- sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
+ sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
Timeout);
}
std::cerr << " " << LLCArgs[i];
std::cerr << "\n";
);
- if (RunProgramWithTimeout(sys::Path(LLCPath), &LLCArgs[0],
+ if (RunProgramWithTimeout(sys::Path(LLCPath), &LLCArgs[0],
sys::Path(), sys::Path(), sys::Path()))
ProcessFailure(sys::Path(LLCPath), &LLCArgs[0]);
}
ToolArgs.clear ();
if (Args) { ToolArgs = *Args; }
}
-
+
virtual int ExecuteProgram(const std::string &Bytecode,
const std::vector<std::string> &Args,
const std::string &InputFile,
const std::string &OutputFile,
- const std::vector<std::string> &SharedLibs =
+ const std::vector<std::string> &SharedLibs =
std::vector<std::string>(), unsigned Timeout =0);
};
}
);
DEBUG(std::cerr << "\nSending output to " << OutputFile << "\n");
return RunProgramWithTimeout(sys::Path(LLIPath), &JITArgs[0],
- sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
+ sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
Timeout);
}
std::cerr << " " << LLCArgs[i];
std::cerr << "\n";
);
- if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
+ if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
sys::Path()))
ProcessFailure(LLCPath, &LLCArgs[0]);
}
FileRemover CFileRemove(OutputCFile);
- return gcc->ExecuteProgram(OutputCFile.toString(), Args, GCC::CFile,
+ return gcc->ExecuteProgram(OutputCFile.toString(), Args, GCC::CFile,
InputFile, OutputFile, SharedLibs, Timeout);
}
const std::vector<std::string> *Args) {
sys::Path LLCPath = FindExecutable("llc", ProgramPath);
if (LLCPath.isEmpty()) {
- Message =
+ Message =
"Cannot find `llc' in executable directory or PATH!\n";
return 0;
}
// Specify the shared libraries to link in...
for (unsigned i = 0, e = SharedLibs.size(); i != e; ++i)
GCCArgs.push_back(SharedLibs[i].c_str());
-
+
// Specify -x explicitly in case the extension is wonky
GCCArgs.push_back("-x");
if (fileType == CFile) {
FileRemover OutputBinaryRemover(OutputBinary);
return RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
- sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
+ sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
Timeout);
}
"-O2", // Optimize the program a bit...
0
};
-
+
std::cout << "<gcc>" << std::flush;
- if (RunProgramWithTimeout(GCCPath, GCCArgs, sys::Path(), sys::Path(),
+ if (RunProgramWithTimeout(GCCPath, GCCArgs, sys::Path(), sys::Path(),
sys::Path())) {
ProcessFailure(GCCPath, GCCArgs);
return 1;
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
#define BZ_OUTBUFF_FULL (-8)
#define BZ_CONFIG_ERROR (-9)
-typedef
+typedef
struct {
char *next_in;
unsigned int avail_in;
void *(*bzalloc)(void *,int,int);
void (*bzfree)(void *,void *);
void *opaque;
- }
+ }
bz_stream;
/*-- Core (low-level) library functions --*/
-BZ_EXTERN int BZ_API(BZ2_bzCompressInit) (
- bz_stream* strm,
- int blockSize100k,
- int verbosity,
- int workFactor
+BZ_EXTERN int BZ_API(BZ2_bzCompressInit) (
+ bz_stream* strm,
+ int blockSize100k,
+ int verbosity,
+ int workFactor
);
-BZ_EXTERN int BZ_API(BZ2_bzCompress) (
- bz_stream* strm,
- int action
+BZ_EXTERN int BZ_API(BZ2_bzCompress) (
+ bz_stream* strm,
+ int action
);
-BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) (
- bz_stream* strm
+BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) (
+ bz_stream* strm
);
-BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) (
- bz_stream *strm,
- int verbosity,
+BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) (
+ bz_stream *strm,
+ int verbosity,
int small
);
-BZ_EXTERN int BZ_API(BZ2_bzDecompress) (
- bz_stream* strm
+BZ_EXTERN int BZ_API(BZ2_bzDecompress) (
+ bz_stream* strm
);
-BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) (
- bz_stream *strm
+BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) (
+ bz_stream *strm
);
typedef void BZFILE;
-BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) (
- int* bzerror,
- FILE* f,
- int verbosity,
+BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) (
+ int* bzerror,
+ FILE* f,
+ int verbosity,
int small,
- void* unused,
- int nUnused
+ void* unused,
+ int nUnused
);
-BZ_EXTERN void BZ_API(BZ2_bzReadClose) (
- int* bzerror,
- BZFILE* b
+BZ_EXTERN void BZ_API(BZ2_bzReadClose) (
+ int* bzerror,
+ BZFILE* b
);
-BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) (
- int* bzerror,
- BZFILE* b,
- void** unused,
- int* nUnused
+BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) (
+ int* bzerror,
+ BZFILE* b,
+ void** unused,
+ int* nUnused
);
-BZ_EXTERN int BZ_API(BZ2_bzRead) (
- int* bzerror,
- BZFILE* b,
- void* buf,
- int len
+BZ_EXTERN int BZ_API(BZ2_bzRead) (
+ int* bzerror,
+ BZFILE* b,
+ void* buf,
+ int len
);
-BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) (
- int* bzerror,
- FILE* f,
- int blockSize100k,
- int verbosity,
- int workFactor
+BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) (
+ int* bzerror,
+ FILE* f,
+ int blockSize100k,
+ int verbosity,
+ int workFactor
);
-BZ_EXTERN void BZ_API(BZ2_bzWrite) (
- int* bzerror,
- BZFILE* b,
- void* buf,
- int len
+BZ_EXTERN void BZ_API(BZ2_bzWrite) (
+ int* bzerror,
+ BZFILE* b,
+ void* buf,
+ int len
);
-BZ_EXTERN void BZ_API(BZ2_bzWriteClose) (
- int* bzerror,
- BZFILE* b,
- int abandon,
- unsigned int* nbytes_in,
- unsigned int* nbytes_out
+BZ_EXTERN void BZ_API(BZ2_bzWriteClose) (
+ int* bzerror,
+ BZFILE* b,
+ int abandon,
+ unsigned int* nbytes_in,
+ unsigned int* nbytes_out
);
-BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) (
- int* bzerror,
- BZFILE* b,
- int abandon,
- unsigned int* nbytes_in_lo32,
- unsigned int* nbytes_in_hi32,
- unsigned int* nbytes_out_lo32,
+BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) (
+ int* bzerror,
+ BZFILE* b,
+ int abandon,
+ unsigned int* nbytes_in_lo32,
+ unsigned int* nbytes_in_hi32,
+ unsigned int* nbytes_out_lo32,
unsigned int* nbytes_out_hi32
);
#endif
/*-- Utility functions --*/
-BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) (
- char* dest,
+BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) (
+ char* dest,
unsigned int* destLen,
- char* source,
+ char* source,
unsigned int sourceLen,
- int blockSize100k,
- int verbosity,
- int workFactor
+ int blockSize100k,
+ int verbosity,
+ int workFactor
);
-BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) (
- char* dest,
+BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) (
+ char* dest,
unsigned int* destLen,
- char* source,
+ char* source,
unsigned int sourceLen,
- int small,
- int verbosity
+ int small,
+ int verbosity
);
int fd,
const char *mode
);
-
+
BZ_EXTERN int BZ_API(BZ2_bzread) (
- BZFILE* b,
- void* buf,
- int len
+ BZFILE* b,
+ void* buf,
+ int len
);
BZ_EXTERN int BZ_API(BZ2_bzwrite) (
- BZFILE* b,
- void* buf,
- int len
+ BZFILE* b,
+ void* buf,
+ int len
);
BZ_EXTERN int BZ_API(BZ2_bzflush) (
);
BZ_EXTERN const char * BZ_API(BZ2_bzerror) (
- BZFILE *b,
+ BZFILE *b,
int *errnum
);
#endif
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
#ifndef __GNUC__
#define __inline__ /* */
-#endif
+#endif
#ifndef BZ_NO_STDIO
extern void BZ2_bz__AssertH__fail ( int errcode );
#define BZ_HDR_Z 0x5a /* 'Z' */
#define BZ_HDR_h 0x68 /* 'h' */
#define BZ_HDR_0 0x30 /* '0' */
-
+
/*-- Constants for the back end. --*/
#define BZ_MAX_ALPHA_SIZE 258
/*-- externs for compression. --*/
-extern void
+extern void
BZ2_blockSort ( EState* );
-extern void
+extern void
BZ2_compressBlock ( EState*, Bool );
-extern void
+extern void
BZ2_bsInitWrite ( EState* );
-extern void
+extern void
BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 );
-extern void
+extern void
BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
Int32 save_N;
Int32 save_curr;
Int32 save_zt;
- Int32 save_zn;
+ Int32 save_zn;
Int32 save_zvec;
Int32 save_zj;
Int32 save_gSel;
/*-- externs for decompression. --*/
-extern Int32
+extern Int32
BZ2_indexIntoF ( Int32, Int32* );
-extern Int32
+extern Int32
BZ2_decompress ( DState* );
-extern void
+extern void
BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
Int32, Int32, Int32 );
//===-- DynamicLibrary.cpp - Runtime link/load libraries --------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This header file implements the operating system DynamicLibrary concept.
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only TRULY operating system
-//=== independent code.
+//=== independent code.
//===----------------------------------------------------------------------===//
static bool did_initialize_ltdl = false;
if (a_handle == 0)
throw std::string("Can't open program as dynamic library");
-
+
handle = a_handle;
OpenedHandles.push_back(a_handle);
}
//===- MappedFile.cpp - MappedFile Support ----------------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the mapped file concept.
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only TRULY operating system
-//=== independent code.
+//=== independent code.
//===----------------------------------------------------------------------===//
}
//===- Memory.cpp - Memory Handling Support ---------------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines some helpful functions for allocating memory and dealing
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only TRULY operating system
-//=== independent code.
+//=== independent code.
//===----------------------------------------------------------------------===//
}
//===-- Path.cpp - Implement OS Path Concept --------------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This header file implements the operating system Path concept.
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only TRULY operating system
-//=== independent code.
+//=== independent code.
//===----------------------------------------------------------------------===//
Path
return GetLLVMDefaultConfigDir();
}
-LLVMFileType
+LLVMFileType
sys::IdentifyFileType(const char*magic, unsigned length) {
assert(magic && "Invalid magic number string");
assert(length >=4 && "Invalid magic number length");
bool
Path::isDynamicLibrary() const {
- if (readable())
+ if (readable())
return hasMagicNumber("\177ELF");
return false;
}
//===-- Process.cpp - Implement OS Process Concept --------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This header file implements the operating system Process concept.
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only TRULY operating system
-//=== independent code.
+//=== independent code.
//===----------------------------------------------------------------------===//
}
//===-- Program.cpp - Implement OS Program Concept --------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This header file implements the operating system Program concept.
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only TRULY operating system
-//=== independent code.
+//=== independent code.
//===----------------------------------------------------------------------===//
}
//===- Signals.cpp - Signal Handling support --------------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines some helpful functions for dealing with the possibility of
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only TRULY operating system
-//=== independent code.
+//=== independent code.
//===----------------------------------------------------------------------===//
}
//===-- TimeValue.cpp - Implement OS TimeValue Concept ----------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the operating system TimeValue concept.
//===- Unix/SUS/Process.cpp - Linux Process Implementation ---- -*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file provides the Linux specific implementation of the Process class.
#include <unistd.h>
//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only code specific to the
+//=== WARNING: Implementation here must contain only code specific to the
//=== SUS (Single Unix Specification).
//===----------------------------------------------------------------------===//
namespace llvm {
using namespace sys;
-unsigned
+unsigned
Process::GetPageSize() {
static const long page_size = sysconf(_SC_PAGE_SIZE);
return static_cast<unsigned>(page_size);
//===- llvm/System/Unix/Unix.h - Common Unix Include File -------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines things specific to Unix implementations.
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
-#endif
+#endif
#ifdef HAVE_ASSERT_H
#include <assert.h>
//===- Win32/Win32.h - Common Win32 Include File ----------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines things specific to Unix implementations.
//===- MRegisterInfo.cpp - Target Register Information Implementation -----===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the MRegisterInfo interface.
Allocatable[*I] = true;
}
return Allocatable;
-}
+}
} // End llvm namespace
//===-- TargetData.cpp - Data size & alignment routines --------------------==//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines target properties related to datatype size/offset/alignment
StructSize = 0;
// Loop over each of the elements, placing them in memory...
- for (StructType::element_iterator TI = ST->element_begin(),
+ for (StructType::element_iterator TI = ST->element_begin(),
TE = ST->element_end(); TI != TE; ++TI) {
const Type *Ty = *TI;
unsigned char A;
TargetData::TargetData(const std::string &TargetName,
bool isLittleEndian, unsigned char PtrSize,
unsigned char PtrAl, unsigned char DoubleAl,
- unsigned char FloatAl, unsigned char LongAl,
+ unsigned char FloatAl, unsigned char LongAl,
unsigned char IntAl, unsigned char ShortAl,
unsigned char ByteAl, unsigned char BoolAl) {
Size = Layout->StructSize; Alignment = Layout->StructAlignment;
return;
}
-
+
default:
assert(0 && "Bad type for getTypeInfo!!!");
return;
//===-- TargetFrameInfo.cpp - Implement machine frame interface -*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// Implements the layout of a stack frame on the target machine.
//===--------------------------------------------------------------------===//
// This method adjusts a stack offset to meet alignment rules of target.
-int
+int
TargetFrameInfo::adjustAlignment(int unalignedOffset, bool growUp,
unsigned align) const {
abort();
// function. The frame contents are obtained from the MachineFunction object
// for the given function. The rest must be implemented by the
// machine-specific subclass.
-//
+//
int
TargetFrameInfo::getIncomingArgOffset(MachineFunction& mcInfo, unsigned argNum)
const {
return 0;
}
-int
+int
TargetFrameInfo::getRegSpillAreaOffset(MachineFunction& mcInfo, bool& growUp)
const {
abort();
return 0;
}
-int
+int
TargetFrameInfo::getDynamicAreaOffset(MachineFunction& mcInfo, bool& growUp)
const {
abort();
//===-- TargetInstrInfo.cpp - Target Instruction Information --------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the TargetInstrInfo class.
namespace llvm {
// External object describing the machine instructions Initialized only when
// the TargetMachine class is created and reset when that class is destroyed.
- //
+ //
// FIXME: UGLY SPARCV9 HACK!
const TargetInstrDescriptor* TargetInstrDescriptors = 0;
}
// NEED TO HANDLE UNSIGNED VALUES SINCE THEY MAY BECOME MUCH
// SMALLER AFTER CASTING TO SIGN-EXTENDED int, short, or char.
// See CreateUIntSetInstruction in SparcInstrInfo.cpp.
-
+
// Now check if the constant fits
if (intValue <= (int64_t) maxImmedValue &&
intValue >= -((int64_t) maxImmedValue+1))
return true;
}
-
+
return false;
}
//===-- TargetMachine.cpp - General Target Information ---------------------==//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file describes the general parts of a Target machine.
cl::desc("Print generated machine code"),
cl::location(PrintMachineCode), cl::init(false));
- cl::opt<bool, true>
+ cl::opt<bool, true>
DisableFPElim("disable-fp-elim",
cl::desc("Disable frame pointer elimination optimization"),
cl::location(NoFramePointerElim),
//===-- TargetMachineRegistry.cpp - Target Auto Registration Impl ---------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file exposes the RegisterTarget class, which TargetMachine
return 0;
} else if (UsableTargets.size() == 1)
return UsableTargets.back().second;
-
+
// Otherwise, take the best target, but make sure we don't have to equally
// good best targets.
std::sort(UsableTargets.begin(), UsableTargets.end());
return 0;
} else if (UsableTargets.size() == 1)
return UsableTargets.back().second;
-
+
// Otherwise, take the best target. If there is a tie, just pick one.
unsigned MaxQual = UsableTargets.front().first;
const Entry *MaxQualTarget = UsableTargets.front().second;
MaxQual = UsableTargets[i].first;
MaxQualTarget = UsableTargets[i].second;
}
-
+
return MaxQualTarget;
}
-
+
//===-- SchedInfo.cpp - Generic code to support target schedulers ----------==//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the generic part of a Scheduler description for a
resourceId_t llvm::CPUResource::nextId = 0;
static std::vector<CPUResource*> *CPUResourceMap = 0;
-
+
CPUResource::CPUResource(const std::string& resourceName, int maxUsers)
: rname(resourceName), rid(nextId++), maxNumUsers(maxUsers) {
if(!CPUResourceMap)
RUConflict(const std::vector<resourceId_t>& fromRVec,
const std::vector<resourceId_t>& toRVec)
{
-
- unsigned fN = fromRVec.size(), tN = toRVec.size();
+
+ unsigned fN = fromRVec.size(), tN = toRVec.size();
unsigned fi = 0, ti = 0;
while (fi < fN && ti < tN) {
static CycleCount_t
-ComputeMinGap(const InstrRUsage &fromRU,
+ComputeMinGap(const InstrRUsage &fromRU,
const InstrRUsage &toRU)
{
CycleCount_t minGap = 0;
-
+
if (fromRU.numBubbles > 0)
minGap = fromRU.numBubbles;
-
+
if (minGap < fromRU.numCycles) {
// only need to check from cycle `minGap' onwards
for (CycleCount_t gap=minGap; gap <= fromRU.numCycles-1; gap++) {
}
}
}
-
+
return minGap;
}
{
assert(MAX_NUM_SLOTS >= (int)getMaxNumIssueTotal()
&& "Insufficient slots for static data! Increase MAX_NUM_SLOTS");
-
+
// First, compute common resource usage info for each class because
// most instructions will probably behave the same as their class.
// Cannot allocate a vector of InstrRUsage so new each one.
- //
+ //
std::vector<InstrRUsage> instrRUForClasses;
instrRUForClasses.resize(numSchedClasses);
for (InstrSchedClass sc = 0; sc < numSchedClasses; sc++) {
instrRUForClasses[sc].setMaxSlots(getMaxNumIssueTotal());
instrRUForClasses[sc].setTo(classRUsages[sc]);
}
-
+
computeInstrResources(instrRUForClasses);
computeIssueGaps(instrRUForClasses);
}
{
int numOpCodes = mii->getNumOpcodes();
instrRUsages.resize(numOpCodes);
-
+
// First get the resource usage information from the class resource usages.
for (MachineOpCode op = 0; op < numOpCodes; ++op) {
InstrSchedClass sc = getSchedClass(op);
assert(sc < numSchedClasses);
instrRUsages[op] = instrRUForClasses[sc];
}
-
+
// Now, modify the resource usages as specified in the deltas.
for (unsigned i = 0; i < numUsageDeltas; ++i) {
MachineOpCode op = usageDeltas[i].opCode;
assert(op < numOpCodes);
instrRUsages[op].addUsageDelta(usageDeltas[i]);
}
-
+
// Then modify the issue restrictions as specified in the deltas.
for (unsigned i = 0; i < numIssueDeltas; ++i) {
MachineOpCode op = issueDeltas[i].opCode;
// First, compute issue gaps between pairs of classes based on common
// resources usages for each class, because most instruction pairs will
// usually behave the same as their class.
- //
+ //
int* classPairGaps =
static_cast<int*>(alloca(sizeof(int) * numSchedClasses * numSchedClasses));
for (InstrSchedClass fromSC=0; fromSC < numSchedClasses; fromSC++)
for (InstrSchedClass toSC=0; toSC < numSchedClasses; toSC++) {
int classPairGap = ComputeMinGap(instrRUForClasses[fromSC],
instrRUForClasses[toSC]);
- classPairGaps[fromSC*numSchedClasses + toSC] = classPairGap;
+ classPairGaps[fromSC*numSchedClasses + toSC] = classPairGap;
}
// Now, for each pair of instructions, use the class pair gap if both
for (MachineOpCode fromOp=0; fromOp < numOpCodes; fromOp++)
for (MachineOpCode toOp=0; toOp < numOpCodes; toOp++) {
- int instrPairGap =
+ int instrPairGap =
(instrRUsages[fromOp].sameAsClass && instrRUsages[toOp].sameAsClass)
? classPairGaps[getSchedClass(fromOp)*numSchedClasses + getSchedClass(toOp)]
: ComputeMinGap(instrRUsages[fromOp], instrRUsages[toOp]);
void InstrRUsage::setTo(const InstrClassRUsage& classRU) {
sameAsClass = true;
isSingleIssue = classRU.isSingleIssue;
- breaksGroup = classRU.breaksGroup;
+ breaksGroup = classRU.breaksGroup;
numBubbles = classRU.numBubbles;
-
+
for (unsigned i=0; i < classRU.numSlots; i++) {
unsigned slot = classRU.feasibleSlots[i];
assert(slot < feasibleSlots.size() && "Invalid slot specified!");
this->feasibleSlots[slot] = true;
}
-
+
numCycles = classRU.totCycles;
resourcesByCycle.resize(this->numCycles);
-
+
for (unsigned i=0; i < classRU.numRUEntries; i++)
for (unsigned c=classRU.V[i].startCycle, NC = c + classRU.V[i].numCycles;
c < NC; c++)
this->resourcesByCycle[c].push_back(classRU.V[i].resourceId);
-
+
// Sort each resource usage vector by resourceId_t to speed up conflict
// checking
for (unsigned i=0; i < this->resourcesByCycle.size(); i++)
// Add the extra resource usage requirements specified in the delta.
// Note that a negative value of `numCycles' means one entry for that
// resource should be deleted for each cycle.
-//
+//
void InstrRUsage::addUsageDelta(const InstrRUsageDelta &delta) {
int NC = delta.numCycles;
sameAsClass = false;
-
+
// resize the resources vector if more cycles are specified
unsigned maxCycles = this->numCycles;
maxCycles = std::max(maxCycles, delta.startCycle + abs(NC) - 1);
this->resourcesByCycle.resize(maxCycles);
this->numCycles = maxCycles;
}
-
+
if (NC >= 0)
for (unsigned c=delta.startCycle, last=c+NC-1; c <= last; c++)
this->resourcesByCycle[c].push_back(delta.resourceId);
//===-- ToolRunner.cpp ----------------------------------------------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the interfaces described in the ToolRunner.h file.
redirects[0] = &StdInFile;
redirects[1] = &StdOutFile;
redirects[2] = &StdErrFile;
-
- return
+
+ return
sys::Program::ExecuteAndWait(ProgramPath, Args, 0, redirects, NumSeconds);
}
ToolArgs.clear ();
if (Args) { ToolArgs = *Args; }
}
-
+
virtual int ExecuteProgram(const std::string &Bytecode,
const std::vector<std::string> &Args,
const std::string &InputFile,
const std::string &OutputFile,
- const std::vector<std::string> &SharedLibs =
+ const std::vector<std::string> &SharedLibs =
std::vector<std::string>(),
unsigned Timeout = 0);
};
std::cerr << "\n";
);
return RunProgramWithTimeout(sys::Path(LLIPath), &LLIArgs[0],
- sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
+ sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
Timeout);
}
std::cerr << " " << LLCArgs[i];
std::cerr << "\n";
);
- if (RunProgramWithTimeout(sys::Path(LLCPath), &LLCArgs[0],
+ if (RunProgramWithTimeout(sys::Path(LLCPath), &LLCArgs[0],
sys::Path(), sys::Path(), sys::Path()))
ProcessFailure(sys::Path(LLCPath), &LLCArgs[0]);
}
ToolArgs.clear ();
if (Args) { ToolArgs = *Args; }
}
-
+
virtual int ExecuteProgram(const std::string &Bytecode,
const std::vector<std::string> &Args,
const std::string &InputFile,
const std::string &OutputFile,
- const std::vector<std::string> &SharedLibs =
+ const std::vector<std::string> &SharedLibs =
std::vector<std::string>(), unsigned Timeout =0);
};
}
);
DEBUG(std::cerr << "\nSending output to " << OutputFile << "\n");
return RunProgramWithTimeout(sys::Path(LLIPath), &JITArgs[0],
- sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
+ sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
Timeout);
}
std::cerr << " " << LLCArgs[i];
std::cerr << "\n";
);
- if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
+ if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
sys::Path()))
ProcessFailure(LLCPath, &LLCArgs[0]);
}
FileRemover CFileRemove(OutputCFile);
- return gcc->ExecuteProgram(OutputCFile.toString(), Args, GCC::CFile,
+ return gcc->ExecuteProgram(OutputCFile.toString(), Args, GCC::CFile,
InputFile, OutputFile, SharedLibs, Timeout);
}
const std::vector<std::string> *Args) {
sys::Path LLCPath = FindExecutable("llc", ProgramPath);
if (LLCPath.isEmpty()) {
- Message =
+ Message =
"Cannot find `llc' in executable directory or PATH!\n";
return 0;
}
// Specify the shared libraries to link in...
for (unsigned i = 0, e = SharedLibs.size(); i != e; ++i)
GCCArgs.push_back(SharedLibs[i].c_str());
-
+
// Specify -x explicitly in case the extension is wonky
GCCArgs.push_back("-x");
if (fileType == CFile) {
FileRemover OutputBinaryRemover(OutputBinary);
return RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
- sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
+ sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
Timeout);
}
"-O2", // Optimize the program a bit...
0
};
-
+
std::cout << "<gcc>" << std::flush;
- if (RunProgramWithTimeout(GCCPath, GCCArgs, sys::Path(), sys::Path(),
+ if (RunProgramWithTimeout(GCCPath, GCCArgs, sys::Path(), sys::Path(),
sys::Path())) {
ProcessFailure(GCCPath, GCCArgs);
return 1;
projects / oota-llvm.git / commitdiff