6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-09-27 15:57:13 +00:00
Code Issues Projects Releases Wiki Activity

Update comments based on Duncan's feedback.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51170 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2008-05-15 23:35:32 +00:00
parent f20d70d57e
commit e2d896fab3
1 changed files with 23 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
include/llvm/Instructions.h
View File

@ -404,7 +404,7 @@ class GetElementPtrInst : public Instruction {
/// getIndexedType - Returns the type of the element that would be loaded with
/// a load instruction with the specified parameters.
///
/// A null type is returned if the indices are invalid for the specified
/// Null is returned if the indices are invalid for the specified
/// pointer type.
///
static const Type *getIndexedType(const Type *Ptr,
@ -497,7 +497,7 @@ public:
/// getIndexedType - Returns the type of the element that would be loaded with
/// a load instruction with the specified parameters.
///
/// A null type is returned if the indices are invalid for the specified
/// Null is returned if the indices are invalid for the specified
/// pointer type.
///
template<typename InputIterator>
@ -1495,8 +1495,8 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)
// ExtractValueInst Class
//===----------------------------------------------------------------------===//
/// ExtractValueInst - This instruction extracts a value
/// from an aggregate value
/// ExtractValueInst - This instruction extracts a struct member or array
/// element value from an aggregate value.
///
class ExtractValueInst : public Instruction {
ExtractValueInst(const ExtractValueInst &EVI);
@ -1526,7 +1526,7 @@ class ExtractValueInst : public Instruction {
/// getIndexedType - Returns the type of the element that would be extracted
/// with an extractvalue instruction with the specified parameters.
///
/// A null type is returned if the indices are invalid for the specified
/// Null is returned if the indices are invalid for the specified
/// pointer type.
///
static const Type *getIndexedType(const Type *Agg,
@ -1549,10 +1549,10 @@ class ExtractValueInst : public Instruction {
return getIndexedType(Ptr, (Value *const*)0, NumIdx);
}
/// Constructors - Create a extractvalue instruction with a base pointer an
/// list of indices. The first ctor can optionally insert before an existing
/// instruction, the second appends the new instruction to the specified
/// BasicBlock.
/// Constructors - Create a extractvalue instruction with a base aggregate
/// value and a list of indices. The first ctor can optionally insert before
/// an existing instruction, the second appends the new instruction to the
/// specified BasicBlock.
template<typename InputIterator>
inline ExtractValueInst(Value *Agg, InputIterator IdxBegin,
InputIterator IdxEnd,
@ -1620,7 +1620,7 @@ public:
/// getIndexedType - Returns the type of the element that would be extracted
/// with an extractvalue instruction with the specified parameters.
///
/// A null type is returned if the indices are invalid for the specified
/// Null is returned if the indices are invalid for the specified
/// pointer type.
///
template<typename InputIterator>
@ -1676,8 +1676,8 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractValueInst, Value)
// InsertValueInst Class
//===----------------------------------------------------------------------===//
/// InsertValueInst - This instruction extracts a value
/// from an aggregate value
/// InsertValueInst - This instruction inserts a struct field of array element
/// value into an aggregate value.
///
class InsertValueInst : public Instruction {
InsertValueInst(const InsertValueInst &IVI);
@ -1705,21 +1705,21 @@ class InsertValueInst : public Instruction {
setName(Name);
}
/// Constructors - Create a insertvalue instruction with a base pointer an
/// list of indices. The first ctor can optionally insert before an existing
/// instruction, the second appends the new instruction to the specified
/// BasicBlock.
/// Constructors - Create a insertvalue instruction with a base aggregate
/// value, a value to insert, and a list of indices. The first ctor can
/// optionally insert before an existing instruction, the second appends
/// the new instruction to the specified BasicBlock.
template<typename InputIterator>
inline InsertValueInst(Value *Agg, Value *Val, InputIterator IdxBegin,
InputIterator IdxEnd,
unsigned Values,
const std::string &Name,
Instruction *InsertBefore);
InputIterator IdxEnd,
unsigned Values,
const std::string &Name,
Instruction *InsertBefore);
template<typename InputIterator>
inline InsertValueInst(Value *Agg, Value *Val,
InputIterator IdxBegin, InputIterator IdxEnd,
unsigned Values,
const std::string &Name, BasicBlock *InsertAtEnd);
InputIterator IdxBegin, InputIterator IdxEnd,
unsigned Values,
const std::string &Name, BasicBlock *InsertAtEnd);
/// Constructors - These two constructors are convenience methods because one
/// and two index insertvalue instructions are so common.