RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-04-04 14:22:26 +00:00
Code Issues Actions Packages 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 /// getIndexedType - Returns the type of the element that would be loaded with
/// a load instruction with the specified parameters. /// 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. /// pointer type.
/// ///
static const Type *getIndexedType(const Type *Ptr, static const Type *getIndexedType(const Type *Ptr,
@ -497,7 +497,7 @@ public:
/// getIndexedType - Returns the type of the element that would be loaded with /// getIndexedType - Returns the type of the element that would be loaded with
/// a load instruction with the specified parameters. /// 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. /// pointer type.
/// ///
template<typename InputIterator> template<typename InputIterator>
@ -1495,8 +1495,8 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)
// ExtractValueInst Class // ExtractValueInst Class
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// ExtractValueInst - This instruction extracts a value /// ExtractValueInst - This instruction extracts a struct member or array
/// from an aggregate value /// element value from an aggregate value.
/// ///
class ExtractValueInst : public Instruction { class ExtractValueInst : public Instruction {
ExtractValueInst(const ExtractValueInst &EVI); ExtractValueInst(const ExtractValueInst &EVI);
@ -1526,7 +1526,7 @@ class ExtractValueInst : public Instruction {
/// getIndexedType - Returns the type of the element that would be extracted /// getIndexedType - Returns the type of the element that would be extracted
/// with an extractvalue instruction with the specified parameters. /// 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. /// pointer type.
/// ///
static const Type *getIndexedType(const Type *Agg, static const Type *getIndexedType(const Type *Agg,
@ -1549,10 +1549,10 @@ class ExtractValueInst : public Instruction {
return getIndexedType(Ptr, (Value *const*)0, NumIdx); return getIndexedType(Ptr, (Value *const*)0, NumIdx);
} }
/// Constructors - Create a extractvalue instruction with a base pointer an /// Constructors - Create a extractvalue instruction with a base aggregate
/// list of indices. The first ctor can optionally insert before an existing /// value and a list of indices. The first ctor can optionally insert before
/// instruction, the second appends the new instruction to the specified /// an existing instruction, the second appends the new instruction to the
/// BasicBlock. /// specified BasicBlock.
template<typename InputIterator> template<typename InputIterator>
inline ExtractValueInst(Value *Agg, InputIterator IdxBegin, inline ExtractValueInst(Value *Agg, InputIterator IdxBegin,
InputIterator IdxEnd, InputIterator IdxEnd,
@ -1620,7 +1620,7 @@ public:
/// getIndexedType - Returns the type of the element that would be extracted /// getIndexedType - Returns the type of the element that would be extracted
/// with an extractvalue instruction with the specified parameters. /// 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. /// pointer type.
/// ///
template<typename InputIterator> template<typename InputIterator>
@ -1676,8 +1676,8 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractValueInst, Value)
// InsertValueInst Class // InsertValueInst Class
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// InsertValueInst - This instruction extracts a value /// InsertValueInst - This instruction inserts a struct field of array element
/// from an aggregate value /// value into an aggregate value.
/// ///
class InsertValueInst : public Instruction { class InsertValueInst : public Instruction {
InsertValueInst(const InsertValueInst &IVI); InsertValueInst(const InsertValueInst &IVI);
@ -1705,21 +1705,21 @@ class InsertValueInst : public Instruction {
setName(Name); setName(Name);
} }
/// Constructors - Create a insertvalue instruction with a base pointer an /// Constructors - Create a insertvalue instruction with a base aggregate
/// list of indices. The first ctor can optionally insert before an existing /// value, a value to insert, and a list of indices. The first ctor can
/// instruction, the second appends the new instruction to the specified /// optionally insert before an existing instruction, the second appends
/// BasicBlock. /// the new instruction to the specified BasicBlock.
template<typename InputIterator> template<typename InputIterator>
inline InsertValueInst(Value *Agg, Value *Val, InputIterator IdxBegin, inline InsertValueInst(Value *Agg, Value *Val, InputIterator IdxBegin,
InputIterator IdxEnd, InputIterator IdxEnd,
unsigned Values, unsigned Values,
const std::string &Name, const std::string &Name,
Instruction *InsertBefore); Instruction *InsertBefore);
template<typename InputIterator> template<typename InputIterator>
inline InsertValueInst(Value *Agg, Value *Val, inline InsertValueInst(Value *Agg, Value *Val,
InputIterator IdxBegin, InputIterator IdxEnd, InputIterator IdxBegin, InputIterator IdxEnd,
unsigned Values, unsigned Values,
const std::string &Name, BasicBlock *InsertAtEnd); const std::string &Name, BasicBlock *InsertAtEnd);
/// Constructors - These two constructors are convenience methods because one /// Constructors - These two constructors are convenience methods because one
/// and two index insertvalue instructions are so common. /// and two index insertvalue instructions are so common.