RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-01-31 12:41:49 +01:00
Code Issues Projects Releases Wiki Activity

Remove trailing whitespace

Browse Source 
llvm-svn: 21409
This commit is contained in:
Misha Brukman 2005-04-21 20:39:54 +00:00
parent 3f0aa3dbf8
commit 4ad5efd1a9
36 changed files with 353 additions and 353 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
include/llvm/Bytecode/Analyzer.h
View File

@ -1,17 +1,17 @@
//===-- llvm/Bytecode/Analyzer.h - Analyzer for Bytecode files --*- 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 functionality is implemented by the lib/Bytecode/Reader library.
// It is used to read VM bytecode files from a file or memory buffer
// and print out a diagnostic analysis of the contents of the file. It is
// intended for three uses: (a) understanding the bytecode format, (b) ensuring
// correctness of bytecode format, (c) statistical analysis of generated
// and print out a diagnostic analysis of the contents of the file. It is
// intended for three uses: (a) understanding the bytecode format, (b) ensuring
// correctness of bytecode format, (c) statistical analysis of generated
// bytecode files.
//
//===----------------------------------------------------------------------===//
@ -30,8 +30,8 @@ namespace llvm {
class Function;
class Module;
/// This structure is used to contain the output of the Bytecode Analysis
/// library. It simply contains fields to hold each item of the analysis
/// This structure is used to contain the output of the Bytecode Analysis
/// library. It simply contains fields to hold each item of the analysis
/// results.
/// @brief Bytecode Analysis results structure
struct BytecodeAnalysis {
@ -68,7 +68,7 @@ struct BytecodeAnalysis {
unsigned vbrCompBytes; ///< Number of vbr bytes (compressed)
unsigned vbrExpdBytes; ///< Number of vbr bytes (expanded)
typedef std::map<BytecodeFormat::CompressedBytecodeBlockIdentifiers,unsigned>
typedef std::map<BytecodeFormat::CompressedBytecodeBlockIdentifiers,unsigned>
BlockSizeMap;
BlockSizeMap BlockSizes;
@ -91,20 +91,20 @@ struct BytecodeAnalysis {
unsigned vbrExpdBytes; ///< Number of vbr bytes (expanded)
};
/// A mapping of function slot numbers to the collected information about
/// A mapping of function slot numbers to the collected information about
/// the function.
std::map<const Function*,BytecodeFunctionInfo> FunctionInfo;
std::map<const Function*,BytecodeFunctionInfo> FunctionInfo;
/// The content of the progressive verification
std::string VerifyInfo;
/// Flags for what should be done
bool detailedResults; ///< If true, FunctionInfo has contents
bool detailedResults; ///< If true, FunctionInfo has contents
bool progressiveVerify; ///< If true, VerifyInfo has contents
};
/// This function is the main entry point into the bytecode analysis library. It
/// allows you to simply provide a \p filename and storage for the \p Results
/// allows you to simply provide a \p filename and storage for the \p Results
/// that will be filled in with the analysis results.
/// @brief Analyze contents of a bytecode File
Module* AnalyzeBytecodeFile(

126
include/llvm/Bytecode/Archive.h
View File

@ -1,16 +1,16 @@
//===-- llvm/Bytecode/Archive.h - LLVM Bytecode Archive ---------*- 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 declares the Archive and ArchiveMember classes that provide
// manipulation of LLVM Archive files. The implementation is provided by the
// lib/Bytecode/Archive library. This library is used to read and write
// archive (*.a) files that contain LLVM bytecode files (or others).
// lib/Bytecode/Archive library. This library is used to read and write
// archive (*.a) files that contain LLVM bytecode files (or others).
//
//===----------------------------------------------------------------------===//
@ -26,7 +26,7 @@
namespace llvm {
// Forward declare classes
// Forward declare classes
class ModuleProvider; // From VMCore
class Module; // From VMCore
class Archive; // Declared below
@ -34,9 +34,9 @@ class ArchiveMemberHeader; // Internal implementation class
/// This class is the main class manipulated by users of the Archive class. It
/// holds information about one member of the Archive. It is also the element
/// stored by the Archive's ilist, the Archive's main abstraction. Because of
/// the special requirements of archive files, users are not permitted to
/// construct ArchiveMember instances. You should obtain them from the methods
/// stored by the Archive's ilist, the Archive's main abstraction. Because of
/// the special requirements of archive files, users are not permitted to
/// construct ArchiveMember instances. You should obtain them from the methods
/// of the Archive class instead.
/// @brief This class represents a single archive member.
class ArchiveMember {
@ -77,19 +77,19 @@ class ArchiveMember {
/// @brief Get the user associated with this archive member.
unsigned getUser() const { return info.user; }
/// The "group" is the owning group of the file per Unix security. This
/// may not have any applicability on non-Unix systems but is a required
/// The "group" is the owning group of the file per Unix security. This
/// may not have any applicability on non-Unix systems but is a required
/// component of the "ar" file format.
/// @brief Get the group associated with this archive member.
unsigned getGroup() const { return info.group; }
/// The "mode" specifies the access permissions for the file per Unix
/// The "mode" specifies the access permissions for the file per Unix
/// security. This may not have any applicabiity on non-Unix systems but is
/// a required component of the "ar" file format.
/// @brief Get the permission mode associated with this archive member.
unsigned getMode() const { return info.mode; }
/// This method returns the time at which the archive member was last
/// This method returns the time at which the archive member was last
/// modified when it was not in the archive.
/// @brief Get the time of last modification of the archive member.
sys::TimeValue getModTime() const { return info.modTime; }
@ -98,7 +98,7 @@ class ArchiveMember {
/// @brief Get the size of the archive member.
unsigned getSize() const { return info.fileSize; }
/// This method returns the total size of the archive member as it
/// This method returns the total size of the archive member as it
/// appears on disk. This includes the file content, the header, the
/// long file name if any, and the padding.
/// @brief Get total on-disk member size.
@ -106,7 +106,7 @@ class ArchiveMember {
/// This method will return a pointer to the in-memory content of the
/// archive member, if it is available. If the data has not been loaded
/// into memory, the return value will be null.
/// into memory, the return value will be null.
/// @returns a pointer to the member's data.
/// @brief Get the data content of the archive member
const void* getData() const { return data; }
@ -147,7 +147,7 @@ class ArchiveMember {
bool hasPath() const { return flags&HasPathFlag; }
/// Long filenames are an artifact of the ar(1) file format which allows
/// up to sixteen characters in its header and doesn't allow a path
/// up to sixteen characters in its header and doesn't allow a path
/// separator character (/). To avoid this, a "long format" member name is
/// allowed that doesn't have this restriction. This method determines if
/// that "long format" is used for this member.
@ -158,7 +158,7 @@ class ArchiveMember {
/// This method returns the status info (like Unix stat(2)) for the archive
/// member. The status info provides the file's size, permissions, and
/// modification time. The contents of the Path::StatusInfo structure, other
/// than the size and modification time, may not have utility on non-Unix
/// than the size and modification time, may not have utility on non-Unix
/// systems.
/// @returns the status info for the archive member
/// @brief Obtain the status info for the archive member
@ -212,14 +212,14 @@ class ArchiveMember {
/// @}
};
/// This class defines the interface to LLVM Archive files. The Archive class
/// presents the archive file as an ilist of ArchiveMember objects. The members
/// This class defines the interface to LLVM Archive files. The Archive class
/// presents the archive file as an ilist of ArchiveMember objects. The members
/// can be rearranged in any fashion either by directly editing the ilist or by
/// using editing methods on the Archive class (recommended). The Archive
/// class also provides several ways of accessing the archive file for various
/// using editing methods on the Archive class (recommended). The Archive
/// class also provides several ways of accessing the archive file for various
/// purposes such as editing and linking. Full symbol table support is provided
/// for loading only those files that resolve symbols. Note that read
/// performance of this library is _crucial_ for performance of JIT type
/// for loading only those files that resolve symbols. Note that read
/// performance of this library is _crucial_ for performance of JIT type
/// applications and the linkers. Consequently, the implementation of the class
/// is optimized for reading.
class Archive {
@ -273,12 +273,12 @@ class Archive {
/// @{
public:
/// This method splices a \p src member from an archive (possibly \p this),
/// to a position just before the member given by \p dest in \p this. When
/// to a position just before the member given by \p dest in \p this. When
/// the archive is written, \p src will be written in its new location.
/// @brief Move a member to a new location
inline void splice(iterator dest, Archive& arch, iterator src)
{ return members.splice(dest,arch.members,src); }
/// This method erases a \p target member from the archive. When the
/// archive is written, it will no longer contain \p target. The associated
/// ArchiveMember is deleted.
@ -290,10 +290,10 @@ class Archive {
/// @{
public:
/// Create an empty archive file and associate it with the \p Filename. This
/// method does not actually create the archive disk file. It creates an
/// method does not actually create the archive disk file. It creates an
/// empty Archive object. If the writeToDisk method is called, the archive
/// file \p Filename will be created at that point, with whatever content
/// the returned Archive object has at that time.
/// file \p Filename will be created at that point, with whatever content
/// the returned Archive object has at that time.
/// @returns An Archive* that represents the new archive file.
/// @brief Create an empty Archive.
static Archive* CreateEmpty(
@ -314,15 +314,15 @@ class Archive {
/// This method opens an existing archive file from \p Filename and reads in
/// its symbol table without reading in any of the archive's members. This
/// reduces both I/O and cpu time in opening the archive if it is to be used
/// solely for symbol lookup (e.g. during linking). The \p Filename must
/// solely for symbol lookup (e.g. during linking). The \p Filename must
/// exist and be an archive file or an exception will be thrown. This form
/// of opening the archive is intended for read-only operations that need to
/// locate members via the symbol table for link editing. Since the archve
/// members are not read by this method, the archive will appear empty upon
/// return. If editing operations are performed on the archive, they will
/// return. If editing operations are performed on the archive, they will
/// completely replace the contents of the archive! It is recommended that
/// if this form of opening the archive is used that only the symbol table
/// lookup methods (getSymbolTable, findModuleDefiningSymbol, and
/// lookup methods (getSymbolTable, findModuleDefiningSymbol, and
/// findModulesDefiningSymbols) be used.
/// @throws std::string if an error occurs opening the file
/// @returns an Archive* that represents the archive file.
@ -333,11 +333,11 @@ class Archive {
);
/// This destructor cleans up the Archive object, releases all memory, and
/// closes files. It does nothing with the archive file on disk. If you
/// haven't used the writeToDisk method by the time the destructor is
/// closes files. It does nothing with the archive file on disk. If you
/// haven't used the writeToDisk method by the time the destructor is
/// called, all changes to the archive will be lost.
/// @throws std::string if an error occurs
/// @brief Destruct in-memory archive
/// @brief Destruct in-memory archive
~Archive();
/// @}
@ -355,15 +355,15 @@ class Archive {
/// @brief Get the iplist of the members
MembersList& getMembers() { return members; }
/// This method allows direct query of the Archive's symbol table. The
/// This method allows direct query of the Archive's symbol table. The
/// symbol table is a std::map of std::string (the symbol) to unsigned (the
/// file offset). Note that for efficiency reasons, the offset stored in
/// file offset). Note that for efficiency reasons, the offset stored in
/// the symbol table is not the actual offset. It is the offset from the
/// beginning of the first "real" file member (after the symbol table). Use
/// the getFirstFileOffset() to obtain that offset and add this value to the
/// offset in the symbol table to obtain the real file offset. Note that
/// there is purposefully no interface provided by Archive to look up
/// members by their offset. Use the findModulesDefiningSymbols and
/// offset in the symbol table to obtain the real file offset. Note that
/// there is purposefully no interface provided by Archive to look up
/// members by their offset. Use the findModulesDefiningSymbols and
/// findModuleDefiningSymbol methods instead.
/// @returns the Archive's symbol table.
/// @brief Get the archive's symbol table
@ -386,15 +386,15 @@ class Archive {
/// @brief Instantiate all the bytecode modules located in the archive
bool getAllModules(std::vector<Module*>& Modules, std::string* ErrMessage);
/// This accessor looks up the \p symbol in the archive's symbol table and
/// This accessor looks up the \p symbol in the archive's symbol table and
/// returns the associated module that defines that symbol. This method can
/// be called as many times as necessary. This is handy for linking the
/// be called as many times as necessary. This is handy for linking the
/// archive into another module based on unresolved symbols. Note that the
/// ModuleProvider returned by this accessor should not be deleted by the
/// caller. It is managed internally by the Archive class. It is possible
/// caller. It is managed internally by the Archive class. It is possible
/// that multiple calls to this accessor will return the same ModuleProvider
/// instance because the associated module defines multiple symbols.
/// @returns The ModuleProvider* found or null if the archive does not
/// instance because the associated module defines multiple symbols.
/// @returns The ModuleProvider* found or null if the archive does not
/// contain a module that defines the \p symbol.
/// @brief Look up a module by symbol name.
ModuleProvider* findModuleDefiningSymbol(
@ -402,10 +402,10 @@ class Archive {
);
/// This method is similar to findModuleDefiningSymbol but allows lookup of
/// more than one symbol at a time. If \p symbols contains a list of
/// undefined symbols in some module, then calling this method is like
/// more than one symbol at a time. If \p symbols contains a list of
/// undefined symbols in some module, then calling this method is like
/// making one complete pass through the archive to resolve symbols but is
/// more efficient than looking at the individual members. Note that on
/// more efficient than looking at the individual members. Note that on
/// exit, the symbols resolved by this method will be removed from \p
/// symbols to ensure they are not re-searched on a subsequent call. If
/// you need to retain the list of symbols, make a copy.
@ -414,11 +414,11 @@ class Archive {
std::set<std::string>& symbols, ///< Symbols to be sought
std::set<ModuleProvider*>& modules ///< The modules matching \p symbols
);
/// This method determines whether the archive is a properly formed llvm
/// bytecode archive. It first makes sure the symbol table has been loaded
/// and has a non-zero size. If it does, then it is an archive. If not,
/// then it tries to load all the bytecode modules of the archive. Finally,
/// This method determines whether the archive is a properly formed llvm
/// bytecode archive. It first makes sure the symbol table has been loaded
/// and has a non-zero size. If it does, then it is an archive. If not,
/// then it tries to load all the bytecode modules of the archive. Finally,
/// it returns whether it was successfull.
/// @returns true if the archive is a proper llvm bytecode archive
/// @brief Determine whether the archive is a proper llvm bytecode archive.
@ -428,15 +428,15 @@ class Archive {
/// @name Mutators
/// @{
public:
/// This method is the only way to get the archive written to disk. It
/// This method is the only way to get the archive written to disk. It
/// creates or overwrites the file specified when \p this was created
/// or opened. The arguments provide options for writing the archive. If
/// \p CreateSymbolTable is true, the archive is scanned for bytecode files
/// and a symbol table of the externally visible function and global
/// and a symbol table of the externally visible function and global
/// variable names is created. If \p TruncateNames is true, the names of the
/// archive members will have their path component stripped and the file
/// name will be truncated at 15 characters. If \p Compress is specified,
/// all archive members will be compressed before being written. If
/// archive members will have their path component stripped and the file
/// name will be truncated at 15 characters. If \p Compress is specified,
/// all archive members will be compressed before being written. If
/// \p PrintSymTab is true, the symbol table will be printed to std::cout.
/// @throws std::string if an error occurs
/// @brief Write (possibly modified) archive contents to disk
@ -449,7 +449,7 @@ class Archive {
/// This method adds a new file to the archive. The \p filename is examined
/// to determine just enough information to create an ArchiveMember object
/// which is then inserted into the Archive object's ilist at the location
/// given by \p where.
/// given by \p where.
/// @throws std::string if an error occurs reading the \p filename.
/// @returns nothing
/// @brief Add a file to the archive.
@ -459,7 +459,7 @@ class Archive {
/// @name Implementation
/// @{
protected:
/// @brief Construct an Archive for \p filename and optionally map it
/// @brief Construct an Archive for \p filename and optionally map it
/// into memory.
Archive(const sys::Path& filename, bool map = false );
@ -486,14 +486,14 @@ class Archive {
bool CreateSymbolTable, bool TruncateNames, bool ShouldCompress);
/// @brief Fill in an ArchiveMemberHeader from ArchiveMember.
bool fillHeader(const ArchiveMember&mbr,
bool fillHeader(const ArchiveMember&mbr,
ArchiveMemberHeader& hdr,int sz, bool TruncateNames) const;
/// This type is used to keep track of bytecode modules loaded from the
/// symbol table. It maps the file offset to a pair that consists of the
/// associated ArchiveMember and the ModuleProvider.
/// associated ArchiveMember and the ModuleProvider.
/// @brief Module mapping type
typedef std::map<unsigned,std::pair<ModuleProvider*,ArchiveMember*> >
typedef std::map<unsigned,std::pair<ModuleProvider*,ArchiveMember*> >
ModuleMap;
/// @}

68
include/llvm/Bytecode/BytecodeHandler.h
View File

@ -1,10 +1,10 @@
//===-- BytecodeHandler.h - Handle Bytecode Parsing Events ------*- 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 defines the interface to the Bytecode Handler. The handler
@ -28,11 +28,11 @@ class ConstantArray;
class Module;
/// This class provides the interface for handling bytecode events during
/// reading of bytecode. The methods on this interface are invoked by the
/// BytecodeReader as it discovers the content of a bytecode stream.
/// This class provides a a clear separation of concerns between recognizing
/// the semantic units of a bytecode file (the Reader) and deciding what to do
/// with them (the Handler).
/// reading of bytecode. The methods on this interface are invoked by the
/// BytecodeReader as it discovers the content of a bytecode stream.
/// This class provides a a clear separation of concerns between recognizing
/// the semantic units of a bytecode file (the Reader) and deciding what to do
/// with them (the Handler).
///
/// The BytecodeReader recognizes the content of the bytecode file and
/// calls the BytecodeHandler methods to let it perform additional tasks. This
@ -40,7 +40,7 @@ class Module;
/// purposes simply by creating a subclass of BytecodeHandler. None of the
/// parsing details need to be understood, only the meaning of the calls
/// made on this interface.
///
///
/// @see BytecodeHandler
/// @brief Handle Bytecode Parsing Events
class BytecodeHandler {
@ -64,8 +64,8 @@ public:
/// This method is called whenever the parser detects an error in the
/// bytecode formatting. It gives the handler a chance to do something
/// with the error message before the parser throws an exception to
/// terminate the parsing.
/// with the error message before the parser throws an exception to
/// terminate the parsing.
/// @brief Handle parsing errors.
virtual void handleError(const std::string& str ) {}
@ -91,8 +91,8 @@ public:
const std::string& moduleId ///< An identifier for the module
) {}
/// This method is called once the version information has been parsed. It
/// provides the information about the version of the bytecode file being
/// This method is called once the version information has been parsed. It
/// provides the information about the version of the bytecode file being
/// read.
/// @brief Handle the bytecode prolog
virtual void handleVersionInfo(
@ -105,10 +105,10 @@ public:
/// contains the global variables and the function placeholders
virtual void handleModuleGlobalsBegin() {}
/// This method is called when a non-initialized global variable is
/// This method is called when a non-initialized global variable is
/// recognized. Its type, constness, and linkage type are provided.
/// @brief Handle a non-initialized global variable
virtual void handleGlobalVariable(
virtual void handleGlobalVariable(
const Type* ElemType, ///< The type of the global variable
bool isConstant, ///< Whether the GV is constant or not
GlobalValue::LinkageTypes,///< The linkage type of the GV
@ -120,20 +120,20 @@ public:
/// provides the number of types that the list contains. The handler
/// should expect that number of calls to handleType.
/// @brief Handle a type
virtual void handleTypeList(
virtual void handleTypeList(
unsigned numEntries ///< The number of entries in the type list
) {}
/// This method is called when a new type is recognized. The type is
/// This method is called when a new type is recognized. The type is
/// converted from the bytecode and passed to this method.
/// @brief Handle a type
virtual void handleType(
virtual void handleType(
const Type* Ty ///< The type that was just recognized
) {}
/// This method is called when the function prototype for a function is
/// encountered in the module globals block.
virtual void handleFunctionDeclaration(
virtual void handleFunctionDeclaration(
Function* Func ///< The function being declared
) {}
@ -146,7 +146,7 @@ public:
/// in the module globals block.
virtual void handleDependentLibrary(const std::string& libName) {}
/// This method is called if the module globals has a non-empty target
/// This method is called if the module globals has a non-empty target
/// triple
virtual void handleTargetTriple(const std::string& triple) {}
@ -159,13 +159,13 @@ public:
virtual void handleCompactionTableBegin() {}
/// @brief Handle start of a compaction table plane
virtual void handleCompactionTablePlane(
virtual void handleCompactionTablePlane(
unsigned Ty, ///< The type of the plane (slot number)
unsigned NumEntries ///< The number of entries in the plane
) {}
/// @brief Handle a type entry in the compaction table
virtual void handleCompactionTableType(
virtual void handleCompactionTableType(
unsigned i, ///< Index in the plane of this type
unsigned TypSlot, ///< Slot number for this type
const Type* ///< The type referenced by this slot
@ -182,27 +182,27 @@ public:
virtual void handleCompactionTableEnd() {}
/// @brief Handle start of a symbol table
virtual void handleSymbolTableBegin(
virtual void handleSymbolTableBegin(
Function* Func, ///< The function to which the ST belongs
SymbolTable* ST ///< The symbol table being filled
) {}
/// @brief Handle start of a symbol table plane
virtual void handleSymbolTablePlane(
virtual void handleSymbolTablePlane(
unsigned TySlot, ///< The slotnum of the type plane
unsigned NumEntries, ///< Number of entries in the plane
const Type* Typ ///< The type of this type plane
) {}
/// @brief Handle a named type in the symbol table
virtual void handleSymbolTableType(
virtual void handleSymbolTableType(
unsigned i, ///< The index of the type in this plane
unsigned slot, ///< Slot number of the named type
const std::string& name ///< Name of the type
) {}
/// @brief Handle a named value in the symbol table
virtual void handleSymbolTableValue(
virtual void handleSymbolTableValue(
unsigned i, ///< The index of the value in this plane
unsigned slot, ///< Slot number of the named value
const std::string& name ///< Name of the value.
@ -227,7 +227,7 @@ public:
unsigned blocknum ///< The block number of the block
) {}
/// This method is called for each instruction that is parsed.
/// This method is called for each instruction that is parsed.
/// @returns true if the instruction is a block terminating instruction
/// @brief Handle an instruction
virtual bool handleInstruction(
@ -246,29 +246,29 @@ public:
virtual void handleGlobalConstantsBegin() {}
/// @brief Handle a constant expression
virtual void handleConstantExpression(
virtual void handleConstantExpression(
unsigned Opcode, ///< Opcode of primary expression operator
std::vector<Constant*> ArgVec, ///< expression args
Constant* C ///< The constant value
) {}
/// @brief Handle a constant array
virtual void handleConstantArray(
virtual void handleConstantArray(
const ArrayType* AT, ///< Type of the array
std::vector<Constant*>& ElementSlots,///< Slot nums for array values
unsigned TypeSlot, ///< Slot # of type
Constant* Val ///< The constant value
) {}
/// @brief Handle a constant structure
virtual void handleConstantStruct(
/// @brief Handle a constant structure
virtual void handleConstantStruct(
const StructType* ST, ///< Type of the struct
std::vector<Constant*>& ElementSlots,///< Slot nums for struct values
Constant* Val ///< The constant value
) {}
/// @brief Handle a constant packed
virtual void handleConstantPacked(
virtual void handleConstantPacked(
const PackedType* PT, ///< Type of the array
std::vector<Constant*>& ElementSlots,///< Slot nums for packed values
unsigned TypeSlot, ///< Slot # of type
@ -276,7 +276,7 @@ public:
) {}
/// @brief Handle a constant pointer
virtual void handleConstantPointer(
virtual void handleConstantPointer(
const PointerType* PT, ///< Type of the pointer
unsigned Slot, ///< Slot num of initializer value
GlobalValue* GV ///< Referenced global value
@ -288,7 +288,7 @@ public:
) {}
/// @brief Handle a primitive constant value
virtual void handleConstantValue(
virtual void handleConstantValue(
Constant * c ///< The constant just defined
) {}

14
include/llvm/Bytecode/Format.h
View File

@ -1,13 +1,13 @@
//===-- llvm/Bytecode/Format.h - VM bytecode file format info ---*- 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 header defines intrinsic constants that are useful to libraries that
// This header defines intrinsic constants that are useful to libraries that
// need to hack on bytecode files directly, like the reader and writer.
//
//===----------------------------------------------------------------------===//
@ -51,9 +51,9 @@ public:
};
/// In LLVM 1.3 format, the identifier and the size of the block are
/// encoded into a single vbr_uint32 with 5 bits for the block identifier
/// and 27-bits for block length. This limits blocks to a maximum of
/// 128MBytes of data, and block types to 31 which should be sufficient
/// encoded into a single vbr_uint32 with 5 bits for the block identifier
/// and 27-bits for block length. This limits blocks to a maximum of
/// 128MBytes of data, and block types to 31 which should be sufficient
/// for the foreseeable usage. Because the values of block identifiers MUST
/// fit within 5 bits (values 1-31), this enumeration is used to ensure
/// smaller values are used for 1.3 and subsequent bytecode versions.
@ -80,7 +80,7 @@ public:
// InstructionList - The instructions in the body of a function. This
// superceeds the old BasicBlock node used in LLVM 1.0.
InstructionListBlockID = 0x07, ///< 1.3 identifier for insruction list
InstructionListBlockID = 0x07, ///< 1.3 identifier for insruction list
// CompactionTable - blocks with this id are used to define local remapping
// tables for a function, allowing the indices used within the function to

14
include/llvm/Bytecode/Reader.h
View File

@ -1,10 +1,10 @@
//===-- llvm/Bytecode/Reader.h - Reader for VM bytecode files ---*- 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 functionality is implemented by the lib/Bytecode/Reader library.
@ -60,21 +60,21 @@ Module* ParseBytecodeBuffer(const unsigned char *Buffer,
/// dependent libraries.
/// @returns true on success, false otherwise
/// @brief Get the list of dependent libraries from a bytecode file.
bool GetBytecodeDependentLibraries(const std::string &fileName,
bool GetBytecodeDependentLibraries(const std::string &fileName,
Module::LibraryListType& deplibs);
/// This function will read only the necessary parts of a bytecode file in order
/// to obtain a list of externally visible global symbols that the bytecode
/// module defines. This is used for archiving and linking when only the list
/// module defines. This is used for archiving and linking when only the list
/// of symbols the module defines is needed.
/// @returns true on success, false otherwise
/// @brief Get a bytecode file's externally visibile defined global symbols.
bool GetBytecodeSymbols(const sys::Path& fileName,
bool GetBytecodeSymbols(const sys::Path& fileName,
std::vector<std::string>& syms);
/// This function will read only the necessary parts of a bytecode buffer in
/// order to obtain a list of externally visible global symbols that the
/// bytecode module defines. This is used for archiving and linking when only
/// order to obtain a list of externally visible global symbols that the
/// bytecode module defines. This is used for archiving and linking when only
/// the list of symbols the module defines is needed and the bytecode is
/// already in memory.
/// @returns the ModuleProvider on success, 0 if the bytecode can't be parsed

10
include/llvm/Bytecode/WriteBytecodePass.h
View File

@ -1,10 +1,10 @@
//===- llvm/Bytecode/WriteBytecodePass.h - Bytecode Writer Pass -*- 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 a simple pass to write the working module to a file after
@ -26,15 +26,15 @@ class WriteBytecodePass : public ModulePass {
bool DeleteStream;
bool CompressFile;
public:
WriteBytecodePass()
WriteBytecodePass()
: Out(&std::cout), DeleteStream(false), CompressFile(true) {}
WriteBytecodePass(std::ostream *o, bool DS = false, bool CF = true)
WriteBytecodePass(std::ostream *o, bool DS = false, bool CF = true)
: Out(o), DeleteStream(DS), CompressFile(CF) {}
inline ~WriteBytecodePass() {
if (DeleteStream) delete Out;
}
bool runOnModule(Module &M) {
WriteBytecodeToFile(&M, *Out, CompressFile );
return false;

6
include/llvm/Bytecode/Writer.h
View File

@ -1,10 +1,10 @@
//===-- llvm/Bytecode/Writer.h - Writer for VM bytecode files ---*- 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 functionality is implemented by the lib/BytecodeWriter library.
@ -28,7 +28,7 @@
namespace llvm {
class Module;
void WriteBytecodeToFile(const Module *M, std::ostream &Out,
void WriteBytecodeToFile(const Module *M, std::ostream &Out,
bool compress = true);
} // End llvm namespace

6
include/llvm/CodeGen/AsmPrinter.h
View File

@ -1,10 +1,10 @@
//===-- llvm/CodeGen/AsmPrinter.h - AsmPrinter Framework --------*- 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 class is intended to be used as a base class for target-specific
@ -78,7 +78,7 @@ namespace llvm {
/// AsciiDirective - This directive allows emission of an ascii string with
/// the standard C escape characters embedded into it.
const char *AsciiDirective;
/// DataDirectives - These directives are used to output some unit of
/// integer data to the current section. If a data directive is set to
/// null, smaller data directives will be used to emit the large sizes.

6
include/llvm/CodeGen/InstrScheduling.h
View File

@ -1,10 +1,10 @@
//===-- InstrScheduling.h - Interface To Instruction Scheduling -*- 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 a minimal, but complete, interface to instruction
@ -22,7 +22,7 @@ class TargetMachine;
//---------------------------------------------------------------------------
// Function: createScheduleInstructionsWithSSAPass(..)
//
//
// Purpose:
// Entry point for instruction scheduling on SSA form.
// Schedules the machine instructions generated by instruction selection.

10
include/llvm/CodeGen/IntrinsicLowering.h
View File

@ -1,12 +1,12 @@
//===-- IntrinsicLowering.h - Intrinsic Function Lowering -------*- 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 IntrinsicLowering interface. This interface allows
// addition of domain-specific or front-end specific intrinsics to LLVM without
// having to modify all of the code generators to support the new intrinsic.
@ -38,7 +38,7 @@
namespace llvm {
class CallInst;
class Module;
class IntrinsicLowering {
public:
virtual ~IntrinsicLowering() {}
@ -67,7 +67,7 @@ namespace llvm {
/// implementation to allow for future extensibility.
struct DefaultIntrinsicLowering : public IntrinsicLowering {
virtual void AddPrototypes(Module &M);
virtual void LowerIntrinsicCall(CallInst *CI);
virtual void LowerIntrinsicCall(CallInst *CI);
};
}

10
include/llvm/CodeGen/LiveVariables.h
View File

@ -1,12 +1,12 @@
//===-- llvm/CodeGen/LiveVariables.h - Live Variable Analysis ---*- 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 implements the LiveVariable analysis pass. For each machine
// instruction in the function, this pass calculates the set of registers that
// are immediately dead after the instruction (i.e., the instruction calculates
@ -23,7 +23,7 @@
// to resolve physical register lifetimes in each basic block). If a physical
// register is not register allocatable, it is not tracked. This is useful for
// things like the stack pointer and condition codes.
//
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_LIVEVARIABLES_H
@ -111,7 +111,7 @@ public:
/// killed_iterator - Iterate over registers killed by a machine instruction
///
typedef std::multimap<MachineInstr*, unsigned>::iterator killed_iterator;
/// killed_begin/end - Get access to the range of registers killed by a
/// machine instruction.
killed_iterator killed_begin(MachineInstr *MI) {

30
include/llvm/CodeGen/MachineBasicBlock.h
View File

@ -1,12 +1,12 @@
//===-- llvm/CodeGen/MachineBasicBlock.h ------------------------*- 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.
//
//
//===----------------------------------------------------------------------===//
//
//
// Collect the sequence of machine instructions for a basic block.
//
//===----------------------------------------------------------------------===//
@ -75,7 +75,7 @@ public:
}
~MachineBasicBlock();
/// getBasicBlock - Return the LLVM basic block that this instance
/// corresponded to originally.
///
@ -111,7 +111,7 @@ public:
typedef std::vector<MachineBasicBlock *>::const_iterator const_pred_iterator;
typedef std::vector<MachineBasicBlock *>::iterator succ_iterator;
typedef std::vector<MachineBasicBlock *>::const_iterator const_succ_iterator;
pred_iterator pred_begin() { return Predecessors.begin (); }
const_pred_iterator pred_begin() const { return Predecessors.begin (); }
pred_iterator pred_end() { return Predecessors.end (); }
@ -162,7 +162,7 @@ public:
iterator erase(iterator I, iterator E) { return Insts.erase(I, E); }
MachineInstr *remove(MachineInstr *I) { return Insts.remove(I); }
void clear() { Insts.clear(); }
/// splice - Take a block of instructions from MBB 'Other' in the range [From,
/// To), and insert them into this MBB right before 'where'.
void splice(iterator where, MachineBasicBlock *Other, iterator From,
@ -219,10 +219,10 @@ template <> struct GraphTraits<MachineBasicBlock *> {
typedef MachineBasicBlock::succ_iterator ChildIteratorType;
static NodeType *getEntryNode(MachineBasicBlock *BB) { return BB; }
static inline ChildIteratorType child_begin(NodeType *N) {
static inline ChildIteratorType child_begin(NodeType *N) {
return N->succ_begin();
}
static inline ChildIteratorType child_end(NodeType *N) {
static inline ChildIteratorType child_end(NodeType *N) {
return N->succ_end();
}
};
@ -232,10 +232,10 @@ template <> struct GraphTraits<const MachineBasicBlock *> {
typedef MachineBasicBlock::const_succ_iterator ChildIteratorType;
static NodeType *getEntryNode(const MachineBasicBlock *BB) { return BB; }
static inline ChildIteratorType child_begin(NodeType *N) {
static inline ChildIteratorType child_begin(NodeType *N) {
return N->succ_begin();
}
static inline ChildIteratorType child_end(NodeType *N) {
static inline ChildIteratorType child_end(NodeType *N) {
return N->succ_end();
}
};
@ -252,10 +252,10 @@ template <> struct GraphTraits<Inverse<MachineBasicBlock*> > {
static NodeType *getEntryNode(Inverse<MachineBasicBlock *> G) {
return G.Graph;
}
static inline ChildIteratorType child_begin(NodeType *N) {
static inline ChildIteratorType child_begin(NodeType *N) {
return N->pred_begin();
}
static inline ChildIteratorType child_end(NodeType *N) {
static inline ChildIteratorType child_end(NodeType *N) {
return N->pred_end();
}
};
@ -264,12 +264,12 @@ template <> struct GraphTraits<Inverse<const MachineBasicBlock*> > {
typedef const MachineBasicBlock NodeType;
typedef MachineBasicBlock::const_pred_iterator ChildIteratorType;
static NodeType *getEntryNode(Inverse<const MachineBasicBlock*> G) {
return G.Graph;
return G.Graph;
}
static inline ChildIteratorType child_begin(NodeType *N) {
static inline ChildIteratorType child_begin(NodeType *N) {
return N->pred_begin();
}
static inline ChildIteratorType child_end(NodeType *N) {
static inline ChildIteratorType child_end(NodeType *N) {
return N->pred_end();
}
};

8
include/llvm/CodeGen/MachineCodeEmitter.h
View File

@ -1,10 +1,10 @@
//===-- llvm/CodeGen/MachineCodeEmitter.h - Code emission -------*- 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 an abstract interface that is used by the machine code
@ -37,7 +37,7 @@ public:
/// about to be code generated.
///
virtual void startFunction(MachineFunction &F) {}
/// finishFunction - This callback is invoked when the specified function has
/// finished code generation.
///
@ -88,7 +88,7 @@ public:
/// addRelocation - Whenever a relocatable address is needed, it should be
/// noted with this interface.
virtual void addRelocation(const MachineRelocation &MR) = 0;
// getConstantPoolEntryAddress - Return the address of the 'Index' entry in
// the constant pool that was last emitted with the 'emitConstantPool' method.
//

6
include/llvm/CodeGen/MachineConstantPool.h
View File

@ -1,12 +1,12 @@
//===-- CodeGen/MachineConstantPool.h - Abstract Constant Pool --*- 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.
//
//
//===----------------------------------------------------------------------===//
//
//
// The MachineConstantPool class keeps track of constants referenced by a
// function which must be spilled to memory. This is used for constants which
// are unable to be used directly as operands to instructions, which typically

10
include/llvm/CodeGen/MachineFrameInfo.h
View File

@ -1,12 +1,12 @@
//===-- CodeGen/MachineFrameInfo.h - Abstract Stack Frame Rep. --*- 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.
//
//
//===----------------------------------------------------------------------===//
//
//
// The MachineFrameInfo class represents an abstract stack frame until
// prolog/epilog code is inserted. This class is key to allowing stack frame
// representation optimizations, such as frame pointer elimination. It also
@ -168,7 +168,7 @@ public:
///
bool hasCalls() const { return HasCalls; }
void setHasCalls(bool V) { HasCalls = V; }
/// getMaxCallFrameSize - Return the maximum size of a call frame that must be
/// allocated for an outgoing function call. This is only available if
/// CallFrameSetup/Destroy pseudo instructions are used by the target, and
@ -186,7 +186,7 @@ public:
Objects.insert(Objects.begin(), StackObject(Size, 1, SPOffset));
return -++NumFixedObjects;
}
/// CreateStackObject - Create a new statically sized stack object, returning
/// a postive identifier to represent it.
///

26
include/llvm/CodeGen/MachineFunction.h
View File

@ -1,18 +1,18 @@
//===-- llvm/CodeGen/MachineFunction.h --------------------------*- 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.
//
//
//===----------------------------------------------------------------------===//
//
//
// Collect native machine code for a function. This class contains a list of
// MachineBasicBlock instances that make up the current compiled function.
//
// This class also contains pointers to various classes which hold
// target-specific information about the generated code.
//
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_MACHINEFUNCTION_H
@ -35,19 +35,19 @@ struct ilist_traits<MachineBasicBlock> {
// this is only set by the MachineFunction owning the ilist
friend class MachineFunction;
MachineFunction* Parent;
public:
ilist_traits<MachineBasicBlock>() : Parent(0) { }
static MachineBasicBlock* getPrev(MachineBasicBlock* N) { return N->Prev; }
static MachineBasicBlock* getNext(MachineBasicBlock* N) { return N->Next; }
static const MachineBasicBlock*
getPrev(const MachineBasicBlock* N) { return N->Prev; }
static const MachineBasicBlock*
getNext(const MachineBasicBlock* N) { return N->Next; }
static void setPrev(MachineBasicBlock* N, MachineBasicBlock* prev) {
N->Prev = prev;
}
@ -179,7 +179,7 @@ public:
/// is an error to add the same register to the same set more than once.
void addLiveIn(unsigned Reg) { LiveIns.push_back(Reg); }
void addLiveOut(unsigned Reg) { LiveOuts.push_back(Reg); }
// Iteration support for live in/out sets. These sets are kept in sorted
// order by their register number.
typedef std::vector<unsigned>::const_iterator liveinout_iterator;
@ -219,7 +219,7 @@ public:
/// in your path.
///
void viewCFG() const;
/// viewCFGOnly - This function is meant for use from the debugger. It works
/// just like viewCFG, but it does not include the contents of basic blocks
/// into the nodes, just the label. If you are only interested in the CFG
@ -256,7 +256,7 @@ public:
// Provide accessors for basic blocks...
const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
BasicBlockListType &getBasicBlockList() { return BasicBlocks; }
//===--------------------------------------------------------------------===//
// BasicBlock iterator forwarding functions
//
@ -331,7 +331,7 @@ template <> struct GraphTraits<const MachineFunction*> :
};
// Provide specializations of GraphTraits to be able to treat a function as a
// Provide specializations of GraphTraits to be able to treat a function as a
// graph of basic blocks... and to walk it in inverse order. Inverse order for
// a function is considered to be when traversing the predecessor edges of a BB
// instead of the successor edges.

4
include/llvm/CodeGen/MachineFunctionPass.h
View File

@ -1,10 +1,10 @@
//===-- MachineFunctionPass.h - Pass for MachineFunctions --------*-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 MachineFunctionPass class. MachineFunctionPass's are

96
include/llvm/CodeGen/MachineInstr.h
View File

@ -1,10 +1,10 @@
//===-- llvm/CodeGen/MachineInstr.h - MachineInstr class --------*- 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 contains the declaration of the MachineInstr class, which is the
@ -35,8 +35,8 @@ template <typename T> struct ilist;
typedef short MachineOpCode;
//===----------------------------------------------------------------------===//
// class MachineOperand
//
// class MachineOperand
//
// Purpose:
// Representation of each machine instruction operand.
// This class is designed so that you can allocate a vector of operands
@ -45,10 +45,10 @@ typedef short MachineOpCode;
// E.g, for this VM instruction:
// ptr = alloca type, numElements
// we generate 2 machine instructions on the SPARC:
//
//
// mul Constant, Numelements -> Reg
// add %sp, Reg -> Ptr
//
//
// Each instruction has 3 operands, listed above. Of those:
// - Reg, NumElements, and Ptr are of operand type MO_Register.
// - Constant is of operand type MO_SignExtendedImmed on the SPARC.
@ -57,16 +57,16 @@ typedef short MachineOpCode;
//
// - Reg will be of virtual register type MO_MInstrVirtualReg. The field
// MachineInstr* minstr will point to the instruction that computes reg.
//
//
// - %sp will be of virtual register type MO_MachineReg.
// The field regNum identifies the machine register.
//
//
// - NumElements will be of virtual register type MO_VirtualReg.
// The field Value* value identifies the value.
//
//
// - Ptr will also be of virtual register type MO_VirtualReg.
// Again, the field Value* value identifies the value.
//
//
//===----------------------------------------------------------------------===//
struct MachineOperand {
@ -108,14 +108,14 @@ public:
MO_ExternalSymbol, // Name of external global symbol
MO_GlobalAddress, // Address of a global value
};
private:
union {
Value* value; // BasicBlockVal for a label operand.
// ConstantVal for a non-address immediate.
// Virtual register for an SSA operand,
// including hidden operands required for
// the generated machine code.
// the generated machine code.
// LLVM global for MO_GlobalAddress.
int64_t immedVal; // Constant value for an explicit constant
@ -134,7 +134,7 @@ private:
// valid for MO_GlobalAddress and MO_ExternalSym
} extra;
void zeroContents () {
void zeroContents () {
memset (&contents, 0, sizeof (contents));
memset (&extra, 0, sizeof (extra));
}
@ -193,9 +193,9 @@ public:
extra = M.extra;
}
~MachineOperand() {}
const MachineOperand &operator=(const MachineOperand &MO) {
contents = MO.contents;
flags = MO.flags;
@ -205,7 +205,7 @@ public:
}
/// getType - Returns the MachineOperandType for this operand.
///
///
MachineOperandType getType() const { return opType; }
/// getUseType - Returns the MachineOperandUseType of this operand.
@ -245,7 +245,7 @@ public:
/// has one. This is deprecated and only used by the SPARC v9 backend.
///
Value* getVRegValueOrNull() const {
return (opType == MO_VirtualRegister || opType == MO_CCRegister ||
return (opType == MO_VirtualRegister || opType == MO_CCRegister ||
isPCRelativeDisp()) ? contents.value : NULL;
}
@ -312,7 +312,7 @@ public:
///
bool hasAllocatedReg() const {
return (extra.regNum >= 0 &&
(opType == MO_VirtualRegister || opType == MO_CCRegister ||
(opType == MO_VirtualRegister || opType == MO_CCRegister ||
opType == MO_MachineRegister));
}
@ -331,13 +331,13 @@ public:
// code.' It's not clear where the duplication is.
assert(hasAllocatedReg() && "This operand cannot have a register number!");
extra.regNum = Reg;
}
}
void setValueReg(Value *val) {
assert(getVRegValueOrNull() != 0 && "Original operand must of type Value*");
contents.value = val;
}
void setImmedValue(int immVal) {
assert(isImmediate() && "Wrong MachineOperand mutator");
contents.immedVal = immVal;
@ -358,35 +358,35 @@ public:
void markLo32() { flags |= LOFLAG32; }
void markHi64() { flags |= HIFLAG64; }
void markLo64() { flags |= LOFLAG64; }
private:
/// setRegForValue - Replaces the Value with its corresponding physical
/// register after register allocation is complete. This is deprecated
/// and only used by the SPARC v9 back-end.
///
void setRegForValue(int reg) {
assert(opType == MO_VirtualRegister || opType == MO_CCRegister ||
assert(opType == MO_VirtualRegister || opType == MO_CCRegister ||
opType == MO_MachineRegister);
extra.regNum = reg;
}
friend class MachineInstr;
};
//===----------------------------------------------------------------------===//
// class MachineInstr
//
// class MachineInstr
//
// Purpose:
// Representation of each machine instruction.
//
//
// MachineOpCode must be an enum, defined separately for each target.
// E.g., It is defined in SparcInstructionSelection.h for the SPARC.
//
//
// There are 2 kinds of operands:
//
// (1) Explicit operands of the machine instruction in vector operands[]
//
//
// (1) Explicit operands of the machine instruction in vector operands[]
//
// (2) "Implicit operands" are values implicitly used or defined by the
// machine instruction, such as arguments to a CALL, return value of
// a CALL (if any), and return value of a RETURN.
@ -426,7 +426,7 @@ public:
/// block.
///
MachineInstr(MachineBasicBlock *MBB, short Opcode, unsigned numOps);
~MachineInstr();
const MachineBasicBlock* getParent() const { return parent; }
@ -439,7 +439,7 @@ public:
/// Access to explicit operands of the instruction.
///
unsigned getNumOperands() const { return operands.size() - numImplicitRefs; }
const MachineOperand& getOperand(unsigned i) const {
assert(i < getNumOperands() && "getOperand() out of range!");
return operands[i];
@ -454,7 +454,7 @@ public:
// This returns the i'th entry in the operand vector.
// That represents the i'th explicit operand or the (i-N)'th implicit operand,
// depending on whether i < N or i >= N.
//
//
const MachineOperand& getExplOrImplOperand(unsigned i) const {
assert(i < operands.size() && "getExplOrImplOperand() out of range!");
return (i < getNumOperands()? getOperand(i)
@ -463,9 +463,9 @@ public:
//
// Access to implicit operands of the instruction
//
//
unsigned getNumImplicitRefs() const{ return numImplicitRefs; }
MachineOperand& getImplicitOp(unsigned i) {
assert(i < numImplicitRefs && "implicit ref# out of range!");
return operands[i + operands.size() - numImplicitRefs];
@ -672,7 +672,7 @@ public:
/// replace - Support to rewrite a machine instruction in place: for now,
/// simply replace() and then set new operands with Set.*Operand methods
/// below.
///
///
void replace(short Opcode, unsigned numOperands);
/// setOpcode - Replace the opcode of the current instruction with a new one.
@ -687,7 +687,7 @@ public:
}
// Access to set the operands when building the machine instruction
//
//
void SetMachineOperandVal(unsigned i,
MachineOperand::MachineOperandType operandType,
Value* V);
@ -702,22 +702,22 @@ public:
unsigned substituteValue(const Value* oldVal, Value* newVal,
bool defsOnly, bool notDefsAndUses,
bool& someArgsWereIgnored);
// SetRegForOperand -
// SetRegForImplicitRef -
// Mark an explicit or implicit operand with its allocated physical register.
//
//
void SetRegForOperand(unsigned i, int regNum);
void SetRegForImplicitRef(unsigned i, int regNum);
//
// Iterator to enumerate machine operands.
//
//
template<class MITy, class VTy>
class ValOpIterator : public forward_iterator<VTy, ptrdiff_t> {
unsigned i;
MITy MI;
void skipToNextVal() {
while (i < MI->getNumOperands() &&
!( (MI->getOperand(i).getType() == MachineOperand::MO_VirtualRegister ||
@ -725,14 +725,14 @@ public:
&& MI->getOperand(i).getVRegValue() != 0))
++i;
}
inline ValOpIterator(MITy mi, unsigned I) : i(I), MI(mi) {
skipToNextVal();
}
public:
typedef ValOpIterator<MITy, VTy> _Self;
inline VTy operator*() const {
return MI->getOperand(i).getVRegValue();
}
@ -742,16 +742,16 @@ public:
inline VTy operator->() const { return operator*(); }
inline bool isUse() const { return MI->getOperand(i).isUse(); }
inline bool isDef() const { return MI->getOperand(i).isDef(); }
inline bool isUse() const { return MI->getOperand(i).isUse(); }
inline bool isDef() const { return MI->getOperand(i).isDef(); }
inline _Self& operator++() { i++; skipToNextVal(); return *this; }
inline _Self operator++(int) { _Self tmp = *this; ++*this; return tmp; }
inline bool operator==(const _Self &y) const {
inline bool operator==(const _Self &y) const {
return i == y.i;
}
inline bool operator!=(const _Self &y) const {
inline bool operator!=(const _Self &y) const {
return !operator==(y);
}

6
include/llvm/CodeGen/MachineInstrBuilder.h
View File

@ -1,10 +1,10 @@
//===-- CodeGen/MachineInstBuilder.h - Simplify creation of MIs -*- 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 exposes a function named BuildMI, which is useful for dramatically
@ -86,7 +86,7 @@ public:
MI->addMachineRegOperand(Reg, Ty);
return *this;
}
/// addImm - Add a new immediate operand.
///
const MachineInstrBuilder &addImm(int Val) const {

4
include/llvm/CodeGen/MachineRelocation.h
View File

@ -1,10 +1,10 @@
//===-- llvm/CodeGen/MachineRelocation.h - Target Relocation ----*- 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 MachineRelocation class.

12
include/llvm/CodeGen/Passes.h
View File

@ -1,10 +1,10 @@
//===-- Passes.h - Target independent code generation passes ----*- 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 interfaces to access the target independent code generation
@ -31,7 +31,7 @@ namespace llvm {
/// last LLVM modifying pass to clean up blocks that are not reachable from
/// the entry block.
FunctionPass *createUnreachableBlockEliminationPass();
/// MachineFunctionPrinter pass - This pass prints out the machine function to
/// standard error, as a debugging tool.
FunctionPass *createMachineFunctionPrinterPass(std::ostream *OS,
@ -62,9 +62,9 @@ namespace llvm {
/// LocalRegisterAllocation Pass - This pass register allocates the input code
/// a basic block at a time, yielding code better than the simple register
/// allocator, but not as good as a global allocator.
///
///
FunctionPass *createLocalRegisterAllocator();
/// LinearScanRegisterAllocation Pass - This pass implements the linear scan
/// register allocation algorithm, a global register allocator.
///
@ -90,7 +90,7 @@ namespace llvm {
/// the current function, which should happen after the function has been
/// emitted to a .s file or to memory.
FunctionPass *createMachineCodeDeleter();
/// getRegisterAllocator - This creates an instance of the register allocator
/// for the Sparc.
FunctionPass *getRegisterAllocator(TargetMachine &T);

84
include/llvm/CodeGen/SchedGraphCommon.h
View File

@ -1,10 +1,10 @@
//===-- SchedGraphCommon.h - Scheduling Base Graph --------------*- 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.
//
//
//===----------------------------------------------------------------------===//
//
// A common graph class that is based on the SSA graph. It includes
@ -47,7 +47,7 @@ public:
typedef std::vector<SchedGraphEdge*>::const_iterator const_iterator;
typedef std::vector<SchedGraphEdge*>::reverse_iterator reverse_iterator;
typedef std::vector<SchedGraphEdge*>::const_reverse_iterator const_reverse_iterator;
// Accessor methods
unsigned getNodeId() const { return ID; }
int getLatency() const { return latency; }
@ -60,7 +60,7 @@ public:
iterator endInEdges() { return inEdges.end(); }
iterator beginOutEdges() { return outEdges.begin(); }
iterator endOutEdges() { return outEdges.end(); }
const_iterator beginInEdges() const { return inEdges.begin(); }
const_iterator endInEdges() const { return inEdges.end(); }
const_iterator beginOutEdges() const { return outEdges.begin(); }
@ -70,29 +70,29 @@ public:
// Debugging support
virtual void print(std::ostream &os) const = 0;
protected:
friend class SchedGraphCommon;
friend class SchedGraphEdge; // give access for adding edges
// disable default constructor and provide a ctor for single-block graphs
SchedGraphNodeCommon(); // DO NOT IMPLEMENT
inline SchedGraphNodeCommon(unsigned Id, int index, int late=0) : ID(Id), latency(late), origIndexInBB(index) {}
virtual ~SchedGraphNodeCommon();
//Functions to add and remove edges
inline void addInEdge(SchedGraphEdge* edge) { inEdges.push_back(edge); }
inline void addOutEdge(SchedGraphEdge* edge) { outEdges.push_back(edge); }
void removeInEdge(const SchedGraphEdge* edge);
void removeOutEdge(const SchedGraphEdge* edge);
};
// ostream << operator for SchedGraphNode class
inline std::ostream &operator<<(std::ostream &os,
inline std::ostream &operator<<(std::ostream &os,
const SchedGraphNodeCommon &node) {
node.print(os);
return os;
@ -112,7 +112,7 @@ public:
enum DataDepOrderType {
TrueDep = 0x1, AntiDep=0x2, OutputDep=0x4, NonDataDep=0x8
};
protected:
SchedGraphNodeCommon* src;
SchedGraphNodeCommon* sink;
@ -120,7 +120,7 @@ protected:
unsigned int depOrderType;
int minDelay; // cached latency (assumes fixed target arch)
int iteDiff;
union {
const Value* val;
int machineRegNum;
@ -130,30 +130,30 @@ protected:
public:
// For all constructors, if minDelay is unspecified, minDelay is
// set to _src->getLatency().
// constructor for CtrlDep or MemoryDep edges, selected by 3rd argument
SchedGraphEdge(SchedGraphNodeCommon* _src, SchedGraphNodeCommon* _sink,
SchedGraphEdgeDepType _depType, unsigned int _depOrderType,
int _minDelay = -1);
// constructor for explicit value dependence (may be true/anti/output)
SchedGraphEdge(SchedGraphNodeCommon* _src, SchedGraphNodeCommon* _sink,
const Value* _val, unsigned int _depOrderType,
int _minDelay = -1);
// constructor for machine register dependence
SchedGraphEdge(SchedGraphNodeCommon* _src,SchedGraphNodeCommon* _sink,
unsigned int _regNum, unsigned int _depOrderType,
int _minDelay = -1);
// constructor for any other machine resource dependences.
// DataDepOrderType is always NonDataDep. It it not an argument to
// avoid overloading ambiguity with previous constructor.
SchedGraphEdge(SchedGraphNodeCommon* _src, SchedGraphNodeCommon* _sink,
ResourceId _resourceId, int _minDelay = -1);
~SchedGraphEdge() {}
SchedGraphNodeCommon* getSrc() const { return src; }
SchedGraphNodeCommon* getSink() const { return sink; }
int getMinDelay() const { return minDelay; }
@ -179,12 +179,12 @@ public:
int getIteDiff() {
return iteDiff;
}
public:
// Debugging support
void print(std::ostream &os) const;
void dump(int indent=0) const;
private:
// disable default ctor
SchedGraphEdge(); // DO NOT IMPLEMENT
@ -197,7 +197,7 @@ inline std::ostream &operator<<(std::ostream &os, const SchedGraphEdge &edge) {
}
class SchedGraphCommon {
protected:
SchedGraphNodeCommon* graphRoot; // the root and leaf are not inserted
SchedGraphNodeCommon* graphLeaf; // in the hash_map (see getNumNodes())
@ -207,16 +207,16 @@ public:
// Accessor methods
//
SchedGraphNodeCommon* getRoot() const { return graphRoot; }
SchedGraphNodeCommon* getLeaf() const { return graphLeaf; }
SchedGraphNodeCommon* getLeaf() const { return graphLeaf; }
//
// Delete nodes or edges from the graph.
//
//
void eraseNode(SchedGraphNodeCommon* node);
void eraseIncomingEdges(SchedGraphNodeCommon* node, bool addDummyEdges = true);
void eraseOutgoingEdges(SchedGraphNodeCommon* node, bool addDummyEdges = true);
void eraseIncidentEdges(SchedGraphNodeCommon* node, bool addDummyEdges = true);
SchedGraphCommon() {}
~SchedGraphCommon();
};
@ -227,30 +227,30 @@ public:
// Ok to make it a template because it shd get instantiated at most twice:
// for <SchedGraphNode, SchedGraphNode::iterator> and
// for <const SchedGraphNode, SchedGraphNode::const_iterator>.
//
//
template <class _NodeType, class _EdgeType, class _EdgeIter>
class SGPredIterator: public bidirectional_iterator<_NodeType, ptrdiff_t> {
protected:
_EdgeIter oi;
public:
typedef SGPredIterator<_NodeType, _EdgeType, _EdgeIter> _Self;
inline SGPredIterator(_EdgeIter startEdge) : oi(startEdge) {}
inline bool operator==(const _Self& x) const { return oi == x.oi; }
inline bool operator!=(const _Self& x) const { return !operator==(x); }
// operator*() differs for pred or succ iterator
inline _NodeType* operator*() const { return (_NodeType*)(*oi)->getSrc(); }
inline _NodeType* operator->() const { return operator*(); }
inline _EdgeType* getEdge() const { return *(oi); }
inline _Self &operator++() { ++oi; return *this; } // Preincrement
inline _Self operator++(int) { // Postincrement
_Self tmp(*this); ++*this; return tmp;
_Self tmp(*this); ++*this; return tmp;
}
inline _Self &operator--() { --oi; return *this; } // Predecrement
inline _Self operator--(int) { // Postdecrement
_Self tmp = *this; --*this; return tmp;
@ -263,22 +263,22 @@ protected:
_EdgeIter oi;
public:
typedef SGSuccIterator<_NodeType, _EdgeType, _EdgeIter> _Self;
inline SGSuccIterator(_EdgeIter startEdge) : oi(startEdge) {}
inline bool operator==(const _Self& x) const { return oi == x.oi; }
inline bool operator!=(const _Self& x) const { return !operator==(x); }
inline _NodeType* operator*() const { return (_NodeType*)(*oi)->getSink(); }
inline _NodeType* operator->() const { return operator*(); }
inline _EdgeType* getEdge() const { return *(oi); }
inline _Self &operator++() { ++oi; return *this; } // Preincrement
inline _Self operator++(int) { // Postincrement
_Self tmp(*this); ++*this; return tmp;
_Self tmp(*this); ++*this; return tmp;
}
inline _Self &operator--() { --oi; return *this; } // Predecrement
inline _Self operator--(int) { // Postdecrement
_Self tmp = *this; --*this; return tmp;

10
include/llvm/CodeGen/SelectionDAG.h
View File

@ -1,15 +1,15 @@
//===-- llvm/CodeGen/SelectionDAG.h - InstSelection DAG ---------*- 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 declares the SelectionDAG class, and transitively defines the
// SDNode class and subclasses.
//
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_SELECTIONDAG_H
@ -62,7 +62,7 @@ public:
typedef std::vector<SDNode*>::const_iterator allnodes_iterator;
allnodes_iterator allnodes_begin() const { return AllNodes.begin(); }
allnodes_iterator allnodes_end() const { return AllNodes.end(); }
/// getRoot - Return the root tag of the SelectionDAG.
///
const SDOperand &getRoot() const { return Root; }

8
include/llvm/CodeGen/SelectionDAGISel.h
View File

@ -1,10 +1,10 @@
//===-- llvm/CodeGen/SelectionDAGISel.h - Common Base Class------*- 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 implements the SelectionDAGISel class, which is used as the common
@ -49,13 +49,13 @@ public:
unsigned MakeReg(MVT::ValueType VT);
virtual void InstructionSelectBasicBlock(SelectionDAG &SD) = 0;
private:
SDOperand CopyValueToVirtualRegister(SelectionDAGLowering &SDL,
Value *V, unsigned Reg);
void SelectBasicBlock(BasicBlock *BB, MachineFunction &MF,
FunctionLoweringInfo &FuncInfo);
void BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB,
std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate,
FunctionLoweringInfo &FuncInfo);

36
include/llvm/CodeGen/SelectionDAGNodes.h
View File

@ -1,12 +1,12 @@
//===-- llvm/CodeGen/SelectionDAGNodes.h - SelectionDAG Nodes ---*- 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 declares the SDNode class and derived classes, which are used to
// represent the nodes and operations present in a SelectionDAG. These nodes
// and operations are machine code level operations, with some similarities to
@ -51,7 +51,7 @@ namespace ISD {
// single token result. This is used to represent the fact that the operand
// operators are independent of each other.
TokenFactor,
// Various leaf nodes.
Constant, ConstantFP, GlobalAddress, FrameIndex, ConstantPool,
BasicBlock, ExternalSymbol,
@ -185,7 +185,7 @@ namespace ISD {
// integer result type.
// ZEXTLOAD loads the integer operand and zero extends it to a larger
// integer result type.
// EXTLOAD is used for two things: floating point extending loads, and
// EXTLOAD is used for two things: floating point extending loads, and
// integer extending loads where it doesn't matter what the high
// bits are set to. The code generator is allowed to codegen this
// into whichever operation is more efficient.
@ -205,7 +205,7 @@ namespace ISD {
DYNAMIC_STACKALLOC,
// Control flow instructions. These all have token chains.
// BR - Unconditional branch. The first operand is the chain
// operand, the second is the MBB to branch to.
BR,
@ -240,7 +240,7 @@ namespace ISD {
MEMSET,
MEMMOVE,
MEMCPY,
// ADJCALLSTACKDOWN/ADJCALLSTACKUP - These operators mark the beginning and
// end of a call sequence and indicate how much the stack pointer needs to
// be adjusted for that particular call. The first operand is a chain, the
@ -284,7 +284,7 @@ namespace ISD {
SETUGT, // 1 0 1 0 True if unordered or greater than
SETUGE, // 1 0 1 1 True if unordered, greater than, or equal
SETULT, // 1 1 0 0 True if unordered or less than
SETULE, // 1 1 0 1 True if unordered, less than, or equal
SETULE, // 1 1 0 1 True if unordered, less than, or equal
SETUNE, // 1 1 1 0 True if unordered or not equal
SETTRUE, // 1 1 1 1 Always true (always folded)
// Don't care operations: undefined if the input is a nan.
@ -293,7 +293,7 @@ namespace ISD {
SETGT, // 1 X 0 1 0 True if greater than
SETGE, // 1 X 0 1 1 True if greater than or equal
SETLT, // 1 X 1 0 0 True if less than
SETLE, // 1 X 1 0 1 True if less than or equal
SETLE, // 1 X 1 0 1 True if less than or equal
SETNE, // 1 X 1 1 0 True if not equal
SETTRUE2, // 1 X 1 1 1 Always true (always folded)
@ -385,7 +385,7 @@ public:
/// getValueType - Return the ValueType of the referenced return value.
///
inline MVT::ValueType getValueType() const;
// Forwarding methods - These forward to the corresponding methods in SDNode.
inline unsigned getOpcode() const;
inline unsigned getNodeDepth() const;
@ -806,11 +806,11 @@ public:
static bool classof(const MVTSDNode *) { return true; }
static bool classof(const SDNode *N) {
return
return
N->getOpcode() == ISD::SIGN_EXTEND_INREG ||
N->getOpcode() == ISD::FP_ROUND_INREG ||
N->getOpcode() == ISD::EXTLOAD ||
N->getOpcode() == ISD::SEXTLOAD ||
N->getOpcode() == ISD::SEXTLOAD ||
N->getOpcode() == ISD::ZEXTLOAD ||
N->getOpcode() == ISD::TRUNCSTORE;
}
@ -819,7 +819,7 @@ public:
class SDNodeIterator : public forward_iterator<SDNode, ptrdiff_t> {
SDNode *Node;
unsigned Operand;
SDNodeIterator(SDNode *N, unsigned Op) : Node(N), Operand(Op) {}
public:
bool operator==(const SDNodeIterator& x) const {
@ -832,18 +832,18 @@ public:
Operand = I.Operand;
return *this;
}
pointer operator*() const {
return Node->getOperand(Operand).Val;
}
pointer operator->() const { return operator*(); }
SDNodeIterator& operator++() { // Preincrement
++Operand;
return *this;
}
SDNodeIterator operator++(int) { // Postincrement
SDNodeIterator tmp = *this; ++*this; return tmp;
SDNodeIterator tmp = *this; ++*this; return tmp;
}
static SDNodeIterator begin(SDNode *N) { return SDNodeIterator(N, 0); }
@ -859,10 +859,10 @@ template <> struct GraphTraits<SDNode*> {
typedef SDNode NodeType;
typedef SDNodeIterator ChildIteratorType;
static inline NodeType *getEntryNode(SDNode *N) { return N; }
static inline ChildIteratorType child_begin(NodeType *N) {
static inline ChildIteratorType child_begin(NodeType *N) {
return SDNodeIterator::begin(N);
}
static inline ChildIteratorType child_end(NodeType *N) {
static inline ChildIteratorType child_end(NodeType *N) {
return SDNodeIterator::end(N);
}
};

6
include/llvm/CodeGen/ValueSet.h
View File

@ -1,10 +1,10 @@
//===-- llvm/CodeGen/ValueSet.h ---------------------------------*- 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 header is OBSOLETE, do not use it for new code.
@ -22,7 +22,7 @@ namespace llvm {
class Value;
// RAV - Used to print values in a form used by the register allocator.
// RAV - Used to print values in a form used by the register allocator.
//
struct RAV { // Register Allocator Value
const Value &V;

4
include/llvm/CodeGen/ValueTypes.h
View File

@ -1,10 +1,10 @@
//===- CodeGen/ValueTypes.h - Low-Level Target independ. types --*- 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 set of low-level target independent types which various

2
include/llvm/Config/alloca.h
View File

@ -3,7 +3,7 @@
*
* 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.
*
*
******************************************************************************
*
* Description:

4
include/llvm/Debugger/Debugger.h
View File

@ -1,10 +1,10 @@
//===- Debugger.h - LLVM debugger library 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.
//
//
//===----------------------------------------------------------------------===//
//
// This file defines the LLVM source-level debugger library interface.

6
include/llvm/Debugger/InferiorProcess.h
View File

@ -1,10 +1,10 @@
//===- InferiorProcess.h - Represent the program being debugged -*- 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 InferiorProcess class, which is used to represent,
@ -59,7 +59,7 @@ namespace llvm {
static InferiorProcess *create(Module *M,
const std::vector<std::string> &Arguments,
const char * const *envp);
// InferiorProcess destructor - Kill the current process. If something
// terrible happens, we throw an exception from the destructor.
virtual ~InferiorProcess() {}

12
include/llvm/Debugger/ProgramInfo.h
View File

@ -1,10 +1,10 @@
//===- ProgramInfo.h - Information about the loaded program -----*- 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 various pieces of information about the currently loaded
@ -70,7 +70,7 @@ namespace llvm {
public:
SourceFileInfo(const GlobalVariable *Desc, const SourceLanguage &Lang);
~SourceFileInfo();
const std::string &getBaseName() const { return BaseName; }
const std::string &getDirectory() const { return Directory; }
unsigned getDebugVersion() const { return Version; }
@ -149,7 +149,7 @@ namespace llvm {
/// with the program, through the getSourceFileFromDesc method. If ALL of
/// the source files are needed, the getSourceFiles() method scans the
/// entire program looking for them.
///
///
std::multimap<std::string, SourceFileInfo*> SourceFileIndex;
/// SourceFunctions - This map contains entries functions in the source
@ -163,7 +163,7 @@ namespace llvm {
/// effectively a small map from the languages that are active in the
/// program to their caches. This can be accessed by the language by the
/// "getLanguageCache" method.
std::vector<std::pair<const SourceLanguage*,
std::vector<std::pair<const SourceLanguage*,
SourceLanguageCache*> > LanguageCaches;
public:
ProgramInfo(Module *m);
@ -172,7 +172,7 @@ namespace llvm {
/// getProgramTimeStamp - Return the time-stamp of the program when it was
/// loaded.
sys::TimeValue getProgramTimeStamp() const { return ProgramTimeStamp; }
//===------------------------------------------------------------------===//
// Interfaces to the source code files that make up the program.
//

8
include/llvm/Debugger/RuntimeInfo.h
View File

@ -1,10 +1,10 @@
//===- RuntimeInfo.h - Information about running program --------*- 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 classes that capture various pieces of information about
@ -42,7 +42,7 @@ namespace llvm {
const SourceFileInfo *SourceInfo;
public:
StackFrame(RuntimeInfo &RI, void *ParentFrameID);
StackFrame &operator=(const StackFrame &RHS) {
FrameID = RHS.FrameID;
FunctionDesc = RHS.FunctionDesc;
@ -80,7 +80,7 @@ namespace llvm {
/// CallStack - This caches information about the current stack trace of the
/// program. This is lazily computed as needed.
std::vector<StackFrame> CallStack;
/// CurrentFrame - The user can traverse the stack frame with the
/// up/down/frame family of commands. This index indicates the current
/// stack frame.

12
include/llvm/Debugger/SourceFile.h
View File

@ -1,10 +1,10 @@
//===- SourceFile.h - Class to represent a source code file -----*- 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 SourceFile class which is used to represent a single
@ -60,11 +60,11 @@ namespace llvm {
/// getDescriptor - Return the debugging decriptor for this source file.
///
const GlobalVariable *getDescriptor() const { return Descriptor; }
/// getFilename - Return the fully resolved path that this file was loaded
/// from.
const std::string &getFilename() const { return Filename.toString(); }
/// getSourceLine - Given a line number, return the start and end of the
/// line in the file. If the line number is invalid, or if the file could
/// not be loaded, null pointers are returned for the start and end of the
@ -72,7 +72,7 @@ namespace llvm {
/// any newlines from the end of the line, to ease formatting of the text.
void getSourceLine(unsigned LineNo, const char *&LineStart,
const char *&LineEnd) const;
/// getNumLines - Return the number of lines the source file contains.
///
unsigned getNumLines() const {
@ -84,7 +84,7 @@ namespace llvm {
/// readFile - Load Filename into memory
///
void readFile();
/// calculateLineOffsets - Compute the LineOffset vector for the current
/// file.
void calculateLineOffsets() const;

4
include/llvm/Debugger/SourceLanguage.h
View File

@ -1,10 +1,10 @@
//===- SourceLanguage.h - Interact with source languages --------*- 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 abstract SourceLanguage interface, which is used by the

6
include/llvm/ExecutionEngine/ExecutionEngine.h
View File

@ -1,10 +1,10 @@
//===- ExecutionEngine.h - Abstract Execution Engine 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.
//
//
//===----------------------------------------------------------------------===//
//
// This file defines the abstract interface that implements execution support
@ -57,7 +57,7 @@ public:
ExecutionEngine(ModuleProvider *P);
ExecutionEngine(Module *M);
virtual ~ExecutionEngine();
Module &getModule() const { return CurMod; }
const TargetData &getTargetData() const { return *TD; }

6
include/llvm/ExecutionEngine/GenericValue.h
View File

@ -1,12 +1,12 @@
//===-- GenericValue.h - Represent any type of LLVM value -------*- 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.
//
//
//===----------------------------------------------------------------------===//
//
//
// The GenericValue class is used to represent an LLVM value of arbitrary type.
//
//===----------------------------------------------------------------------===//