llvm.org GIT mirror llvm / 181b6c9
Fix minor doxygen nits. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40854 91177308-0d34-0410-b5e6-96231b3b80d8 Reid Spencer 13 years ago
13 changed file(s) with 45 addition(s) and 28 deletion(s). Raw diff Collapse all Expand all
462462 /// into memory.
463463 Archive(const sys::Path& filename);
464464
465 /// @param data The symbol table data to be parsed
466 /// @param len The length of the symbol table data
465467 /// @param error Set to address of a std::string to get error messages
466468 /// @returns false on error
467469 /// @brief Parse the symbol table at \p data.
475477 std::string* error ///< Optional error message catcher
476478 );
477479
478 /// @param error Set to address of a std::string to get error messages
480 /// @param ErrMessage Set to address of a std::string to get error messages
479481 /// @returns false on error
480482 /// @brief Check that the archive signature is correct
481483 bool checkSignature(std::string* ErrMessage);
482484
483 /// @param error Set to address of a std::string to get error messages
485 /// @param ErrMessage Set to address of a std::string to get error messages
484486 /// @returns false on error
485487 /// @brief Load the entire archive.
486488 bool loadArchive(std::string* ErrMessage);
487489
488 /// @param error Set to address of a std::string to get error messages
490 /// @param ErrMessage Set to address of a std::string to get error messages
489491 /// @returns false on error
490492 /// @brief Load just the symbol table.
491493 bool loadSymbolTable(std::string* ErrMessage);
239239
240240 /// EmitString - Emit a string with quotes and a null terminator.
241241 /// Special characters are emitted properly.
242 /// \literal (Eg. '\t') \endliteral
242 /// @verbatim (Eg. '\t') @endverbatim
243243 void EmitString(const std::string &String) const;
244244
245245 //===------------------------------------------------------------------===//
310310 bool isString() const;
311311
312312 /// isCString - This method returns true if the array is a string (see
313 /// @verbatim
313314 /// isString) and it ends in a null byte \0 and does not contains any other
315 /// @endverbatim
314316 /// null bytes except its terminator.
315317 bool isCString() const;
316318
203203 /// found in one library, based on the unresolved symbols in the composite
204204 /// module.The \p Library should be the base name of a library, as if given
205205 /// with the -l option of a linker tool. The Linker's LibPaths are searched
206 /// for the \P Library and if found, it will be linked in with via the
206 /// for the \p Library and if found, it will be linked in with via the
207207 /// LinkInArchive method. If an error occurs, the Linker's error string is
208208 /// set.
209209 /// @see LinkInArchive
8888 return Insert(new ReturnInst());
8989 }
9090
91 /// CreateRet - Create a 'ret ' instruction.
91 /// @verbatim CreateRet - Create a 'ret ' instruction. @endverbatim
9292 ReturnInst *CreateRet(Value *V) {
9393 return Insert(new ReturnInst(V));
9494 }
7070 void setUseQuotes(bool Val) { UseQuotes = Val; }
7171
7272 /// setPreserveAsmNames - If the mangler should not strip off the asm name
73 /// identifier (\001), this should be set.
73 /// @verbatim identifier (\001), this should be set. @endverbatim
7474 void setPreserveAsmNames(bool Val) { PreserveAsmNames = Val; }
7575
7676 /// Acceptable Characters - This allows the target to specify which characters
2222 /// of memory, and provides simple methods for reading files and standard input
2323 /// into a memory buffer. In addition to basic access to the characters in the
2424 /// file, this interface guarantees you can read one character past the end of
25 /// the file, and that this character will read as '\0'.
25 /// @verbatim the file, and that this character will read as '\0'. @endverbatim
2626 class MemoryBuffer {
2727 const char *BufferStart; // Start of the buffer.
2828 const char *BufferEnd; // End of the buffer.
2020
2121 /// BaseStream - Acts like the STL streams. It's a wrapper for the std::cerr,
2222 /// std::cout, std::cin, etc. streams. However, it doesn't require #including
23 /// in every file (doing so increases static c'tors & d'tors in the
24 /// object code).
23 /// @verbatim @endverbatm in every file (doing so increases static
24 /// c'tors & d'tors in the object code).
2525 ///
2626 template
2727 class BaseStream {
176176 /// This constructor will accept a character range as a path. No checking
177177 /// is done on this path to determine if it is valid. To determine
178178 /// validity of the path, use the isValid method.
179 /// @param p The path to assign.
179 /// @param StrStart A pointer to the first character of the path name
180 /// @param StrLen The length of the path name at StrStart
180181 /// @brief Construct a Path from a string.
181182 explicit Path(const char *StrStart, unsigned StrLen)
182183 : path(StrStart, StrStart+StrLen) {}
279280
280281 /// This function determines if the path name is absolute, as opposed to
281282 /// relative.
282 /// @breif Determine if the path is absolute.
283 /// @brief Determine if the path is absolute.
283284 bool isAbsolute() const;
284285
285286 /// This function opens the file associated with the path name provided by
511512 /// directory, recursively. If the Path refers to a file, the
512513 /// \p destroy_contents parameter is ignored.
513514 /// @param destroy_contents Indicates whether the contents of a destroyed
515 /// @param Err An optional string to receive an error message.
514516 /// directory should also be destroyed (recursively).
515517 /// @returns false if the file/directory was destroyed, true on error.
516518 /// @brief Removes the file or directory from the filesystem.
553555 /// This constructor will accept a std::string as a path. No checking is
554556 /// done on this path to determine if it is valid. To determine validity
555557 /// of the path, use the isValid method.
556 /// @param p The path to assign.
557558 /// @brief Construct a Path from a string.
558 explicit PathWithStatus(const std::string& p)
559 : Path(p), status(), fsIsValid(false) {}
559 explicit PathWithStatus(
560 const std::string& p ///< The path to assign.
561 ) : Path(p), status(), fsIsValid(false) {}
560562
561563 /// This constructor will accept a character range as a path. No checking
562564 /// is done on this path to determine if it is valid. To determine
563565 /// validity of the path, use the isValid method.
564 /// @param p The path to assign.
565566 /// @brief Construct a Path from a string.
566 explicit PathWithStatus(const char *StrStart, unsigned StrLen)
567 : Path(StrStart, StrLen), status(), fsIsValid(false) {}
567 explicit PathWithStatus(
568 const char *StrStart, ///< Pointer to the first character of the path
569 unsigned StrLen ///< Length of the path.
570 ) : Path(StrStart, StrLen), status(), fsIsValid(false) {}
568571
569572 /// Makes a copy of \p that to \p this.
570573 /// @returns \p this
103103 /// will enclose any GlobalVariable that points to a function.
104104 /// For example, this is used by the IA64 backend to materialize
105105 /// function descriptors, by decorating the ".data8" object with the
106 /// \literal @fptr( ) \endliteral
106 /// @verbatim @fptr( ) @endverbatim
107107 /// link-relocation operator.
108108 ///
109109 const char *FunctionAddrPrefix; // Defaults to ""
189189 const char *JumpTableDirective;
190190
191191 /// CStringSection - If not null, this allows for special handling of
192 /// cstring constants (\0 terminated string that does not contain any
192 /// cstring constants (null terminated string that does not contain any
193193 /// other null bytes) on this target. This is commonly supported as
194194 /// ".cstring".
195195 const char *CStringSection; // Defaults to NULL
229229 /// LCOMMDirective - This is the name of a directive (if supported) that can
230230 /// be used to efficiently declare a local (internal) block of zero
231231 /// initialized data in the .bss/.data section. The syntax expected is:
232 /// \literal SYMBOLNAME LENGTHINBYTES, ALIGNMENT
233 /// \endliteral
232 /// @verbatim SYMBOLNAME LENGTHINBYTES, ALIGNMENT
233 /// @endverbatim
234234 const char *LCOMMDirective; // Defaults to null.
235235
236236 const char *COMMDirective; // Defaults to "\t.comm\t".
5757
5858 //===----------------------------------------------------------------------===//
5959 /// DWLabel - Labels are used to track locations in the assembler file.
60 /// Labels appear in the form , where the tag is a
61 /// category of label (Ex. location) and number is a value unique in that
62 /// category.
60 /// Labels appear in the form @verbatim @endverbatim,
61 /// where the tag is a category of label (Ex. location) and number is a value
62 /// unique in that category.
6363 class DWLabel {
6464 public:
6565 /// Tag - Label category tag. Should always be a staticly declared C string.
145145 [E|e]: Endianness. "E" specifies a big-endian target data model, "e"
146146 specifies a little-endian target data model.
147147

148 p:::: Pointer size, ABI and preferred
149 alignment.
148 p:@verbatim::@endverbatim: Pointer size,
149 ABI and preferred alignment.
150150

151 ::: Numeric type alignment. Type is
151 @verbatim::@endverbatim: Numeric type alignment. Type is
152152 one of i|f|v|a, corresponding to integer, floating point, vector (aka
153153 packed) or aggregate. Size indicates the size, e.g., 32 or 64 bits.
154154 \p
369369 ParamAttr::ByVal | ParamAttr::InReg |
370370 ParamAttr::Nest | ParamAttr::StructRet;
371371
372 const uint16_t MutuallyIncompatible2 =
373 ParamAttr::ZExt | ParamAttr::SExt;
374
372375 const uint16_t IntegerTypeOnly =
373376 ParamAttr::SExt | ParamAttr::ZExt;
374377
385388 uint16_t RetI = Attrs->getParamAttrs(0) & ReturnIncompatible;
386389 Assert1(!RetI, "Attribute " + Attrs->getParamAttrsText(RetI) +
387390 "should not apply to functions!", &F);
391 uint16_t MutI = Attrs->getParamAttrs(0) & MutuallyIncompatible2;
392 Assert1(MutI != MutuallyIncompatible2, "Attributes" +
393 Attrs->getParamAttrsText(MutI) + "are incompatible!", &F);
388394
389395 for (FunctionType::param_iterator I = FT->param_begin(),
390396 E = FT->param_end(); I != E; ++I, ++Idx) {
398404 uint16_t MutI = Attr & MutuallyIncompatible;
399405 Assert1(!(MutI & (MutI - 1)), "Attributes " +
400406 Attrs->getParamAttrsText(MutI) + "are incompatible!", &F);
407
408 uint16_t MutI2 = Attr & MutuallyIncompatible2;
409 Assert1(MutI2 != MutuallyIncompatible2, "Attributes" +
410 Attrs->getParamAttrsText(MutI2) + "are incompatible!", &F);
401411
402412 uint16_t IType = Attr & IntegerTypeOnly;
403413 Assert1(!IType || FT->getParamType(Idx-1)->isInteger(),