llvm.org GIT mirror llvm / c5252da
Fix Doxygen issues: * wrap code blocks in \code ... \endcode; * refer to parameter names in paragraphs correctly (\arg is not what most people want -- it starts a new paragraph); * use \param instead of \arg to document parameters in order to be consistent with the rest of the codebase. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@163902 91177308-0d34-0410-b5e6-96231b3b80d8 Dmitri Gribenko 7 years ago
30 changed file(s) with 113 addition(s) and 95 deletion(s). Raw diff Collapse all Expand all
4747 public:
4848 virtual ~DAGDeltaAlgorithm() {}
4949
50 /// Run - Minimize the DAG formed by the \arg Changes vertices and the \arg
51 /// Dependencies edges by executing \see ExecuteOneTest() on subsets of
50 /// Run - Minimize the DAG formed by the \p Changes vertices and the
51 /// \p Dependencies edges by executing \see ExecuteOneTest() on subsets of
5252 /// changes and returning the smallest set which still satisfies the test
53 /// predicate and the input \arg Dependencies.
53 /// predicate and the input \p Dependencies.
5454 ///
5555 /// \param Changes The list of changes.
5656 ///
5757 /// \param Dependencies The list of dependencies amongst changes. For each
58 /// (x,y) in \arg Dependencies, both x and y must be in \arg Changes. The
58 /// (x,y) in \p Dependencies, both x and y must be in \p Changes. The
5959 /// minimization algorithm guarantees that for each tested changed set S,
6060 /// \f$ x \in S \f$ implies \f$ y \in S \f$. It is an error to have cyclic
6161 /// dependencies.
6767 const changesetlist_ty &Sets,
6868 const changeset_ty &Required) {}
6969
70 /// ExecuteOneTest - Execute a single test predicate on the change set \arg S.
70 /// ExecuteOneTest - Execute a single test predicate on the change set \p S.
7171 virtual bool ExecuteOneTest(const changeset_ty &S) = 0;
7272 };
7373
4444 /// since we always reduce following a success.
4545 std::set FailedTestsCache;
4646
47 /// GetTestResult - Get the test result for the \arg Changes from the
47 /// GetTestResult - Get the test result for the \p Changes from the
4848 /// cache, executing the test if necessary.
4949 ///
5050 /// \param Changes - The change set to test.
5151 /// \return - The test result.
5252 bool GetTestResult(const changeset_ty &Changes);
5353
54 /// Split - Partition a set of changes \arg S into one or two subsets.
54 /// Split - Partition a set of changes \p S into one or two subsets.
5555 void Split(const changeset_ty &S, changesetlist_ty &Res);
5656
57 /// Delta - Minimize a set of \arg Changes which has been partioned into
57 /// Delta - Minimize a set of \p Changes which has been partioned into
5858 /// smaller sets, by attempting to remove individual subsets.
5959 changeset_ty Delta(const changeset_ty &Changes,
6060 const changesetlist_ty &Sets);
6161
62 /// Search - Search for a subset (or subsets) in \arg Sets which can be
63 /// removed from \arg Changes while still satisfying the predicate.
62 /// Search - Search for a subset (or subsets) in \p Sets which can be
63 /// removed from \p Changes while still satisfying the predicate.
6464 ///
6565 /// \param Res - On success, a subset of Changes which satisfies the
6666 /// predicate.
7373 virtual void UpdatedSearchState(const changeset_ty &Changes,
7474 const changesetlist_ty &Sets) {}
7575
76 /// ExecuteOneTest - Execute a single test predicate on the change set \arg S.
76 /// ExecuteOneTest - Execute a single test predicate on the change set \p S.
7777 virtual bool ExecuteOneTest(const changeset_ty &S) = 0;
7878
7979 public:
8080 virtual ~DeltaAlgorithm();
8181
82 /// Run - Minimize the set \arg Changes by executing \see ExecuteOneTest() on
82 /// Run - Minimize the set \p Changes by executing \see ExecuteOneTest() on
8383 /// subsets of changes and returning the smallest set which still satisfies
8484 /// the test predicate.
8585 changeset_ty Run(const changeset_ty &Changes);
8787
8888 /// \brief Erase an entry from the mapping table.
8989 ///
90 /// \returns The address that \arg ToUnmap was happed to.
90 /// \returns The address that \p ToUnmap was happed to.
9191 void *RemoveMapping(const MutexGuard &, const GlobalValue *ToUnmap);
9292 };
9393
9898
9999 /// @}
100100
101 /// applyFixup - Apply the \arg Value for given \arg Fixup into the provided
101 /// applyFixup - Apply the \p Value for given \p Fixup into the provided
102102 /// data fragment, at the offset specified by the fixup and following the
103103 /// fixup kind as appropriate.
104104 virtual void applyFixup(const MCFixup &Fixup, char *Data, unsigned DataSize,
224224 /// Value - Value to use for filling padding bytes.
225225 int64_t Value;
226226
227 /// ValueSize - The size of the integer (in bytes) of \arg Value.
227 /// ValueSize - The size of the integer (in bytes) of \p Value.
228228 unsigned ValueSize;
229229
230230 /// MaxBytesToEmit - The maximum number of bytes to emit; if the alignment
271271 /// Value - Value to use for filling bytes.
272272 int64_t Value;
273273
274 /// ValueSize - The size (in bytes) of \arg Value to use when filling, or 0 if
274 /// ValueSize - The size (in bytes) of \p Value to use when filling, or 0 if
275275 /// this is a virtual fill fragment.
276276 unsigned ValueSize;
277277
737737 /// \param Value [out] On return, the value of the fixup as currently laid
738738 /// out.
739739 /// \return Whether the fixup value was fully resolved. This is true if the
740 /// \arg Value result is fixed, otherwise the value may change due to
740 /// \p Value result is fixed, otherwise the value may change due to
741741 /// relocation.
742742 bool evaluateFixup(const MCAsmLayout &Layout,
743743 const MCFixup &Fixup, const MCFragment *DF,
774774
775775 public:
776776 /// Compute the effective fragment size assuming it is laid out at the given
777 /// \arg SectionAddress and \arg FragmentOffset.
777 /// \p SectionAddress and \p FragmentOffset.
778778 uint64_t computeFragmentSize(const MCAsmLayout &Layout,
779779 const MCFragment &F) const;
780780
803803 public:
804804 /// Construct a new assembler instance.
805805 ///
806 /// \arg OS - The stream to output to.
806 /// \param OS The stream to output to.
807807 //
808808 // FIXME: How are we going to parameterize this? Two obvious options are stay
809809 // concrete and require clients to pass in a target like object. The other
823823 MCObjectWriter &getWriter() const { return Writer; }
824824
825825 /// Finish - Do final processing and write the object to the output stream.
826 /// \arg Writer is used for custom object writer (as the MCJIT does),
826 /// \p Writer is used for custom object writer (as the MCJIT does),
827827 /// if not specified it is automatically created from backend.
828828 void Finish();
829829
2828 public:
2929 virtual ~MCCodeEmitter();
3030
31 /// EncodeInstruction - Encode the given \arg Inst to bytes on the output
32 /// stream \arg OS.
31 /// EncodeInstruction - Encode the given \p Inst to bytes on the output
32 /// stream \p OS.
3333 virtual void EncodeInstruction(const MCInst &Inst, raw_ostream &OS,
3434 SmallVectorImpl &Fixups) const = 0;
3535 };
5858 unsigned getDirIndex() const { return DirIndex; }
5959
6060
61 /// print - Print the value to the stream \arg OS.
61 /// print - Print the value to the stream \p OS.
6262 void print(raw_ostream &OS) const;
6363
6464 /// dump - Print the value to stderr.
181181 void dump() const;
182182
183183 /// \brief Dump the MCInst as prettily as possible using the additional MC
184 /// structures, if given. Operators are separated by the \arg Separator
184 /// structures, if given. Operators are separated by the \p Separator
185185 /// string.
186186 void dump_pretty(raw_ostream &OS, const MCAsmInfo *MAI = 0,
187187 const MCInstPrinter *Printer = 0,
4141 /// Label.
4242 unsigned incInstance() { return ++Instance; }
4343
44 /// print - Print the value to the stream \arg OS.
44 /// print - Print the value to the stream \p OS.
4545 void print(raw_ostream &OS) const;
4646
4747 /// dump - Print the value to stderr.
152152
153153 /// WriteSegmentLoadCommand - Write a segment load command.
154154 ///
155 /// \arg NumSections - The number of sections in this segment.
156 /// \arg SectionDataSize - The total size of the sections.
155 /// \param NumSections The number of sections in this segment.
156 /// \param SectionDataSize The total size of the sections.
157157 void WriteSegmentLoadCommand(unsigned NumSections,
158158 uint64_t VMSize,
159159 uint64_t SectionDataStartOffset,
169169 /// getKind - Get the kind of current token.
170170 AsmToken::TokenKind getKind() const { return CurTok.getKind(); }
171171
172 /// is - Check if the current token has kind \arg K.
172 /// is - Check if the current token has kind \p K.
173173 bool is(AsmToken::TokenKind K) const { return CurTok.is(K); }
174174
175 /// isNot - Check if the current token has kind \arg K.
175 /// isNot - Check if the current token has kind \p K.
176176 bool isNot(AsmToken::TokenKind K) const { return CurTok.isNot(K); }
177177 };
178178
7272 /// Run - Run the parser on the input source buffer.
7373 virtual bool Run(bool NoInitialTextSection, bool NoFinalize = false) = 0;
7474
75 /// Warning - Emit a warning at the location \arg L, with the message \arg
76 /// Msg.
75 /// Warning - Emit a warning at the location \p L, with the message \p Msg.
7776 ///
7877 /// \return The return value is true, if warnings are fatal.
7978 virtual bool Warning(SMLoc L, const Twine &Msg,
8079 ArrayRef Ranges = ArrayRef()) = 0;
8180
82 /// Error - Emit an error at the location \arg L, with the message \arg
83 /// Msg.
81 /// Error - Emit an error at the location \p L, with the message \p Msg.
8482 ///
8583 /// \return The return value is always true, as an idiomatic convenience to
8684 /// clients.
9997 ArrayRef Ranges = ArrayRef());
10098
10199 /// ParseIdentifier - Parse an identifier or string (as a quoted identifier)
102 /// and set \arg Res to the identifier contents.
100 /// and set \p Res to the identifier contents.
103101 virtual bool ParseIdentifier(StringRef &Res) = 0;
104102
105103 /// \brief Parse up to the end of statement and return the contents from the
4242 public:
4343 virtual ~MCAsmParserExtension();
4444
45 /// \brief Initialize the extension for parsing using the given \arg
46 /// Parser. The extension should use the AsmParser interfaces to register its
45 /// \brief Initialize the extension for parsing using the given \p Parser.
46 /// The extension should use the AsmParser interfaces to register its
4747 /// parsing routines.
4848 virtual void Initialize(MCAsmParser &Parser);
4949
341341 /// @name Generating Data
342342 /// @{
343343
344 /// EmitBytes - Emit the bytes in \arg Data into the output.
344 /// EmitBytes - Emit the bytes in \p Data into the output.
345345 ///
346346 /// This is used to implement assembler directives such as .byte, .ascii,
347347 /// etc.
572572 /// InstPrint.
573573 ///
574574 /// \param CE - If given, a code emitter to use to show the instruction
575 /// encoding inline with the assembly. This method takes ownership of \arg CE.
575 /// encoding inline with the assembly. This method takes ownership of \p CE.
576576 ///
577577 /// \param TAB - If given, a target asm backend to use to show the fixup
578578 /// information in conjunction with encoding information. This method takes
579 /// ownership of \arg TAB.
579 /// ownership of \p TAB.
580580 ///
581581 /// \param ShowInst - Whether to show the MCInst representation inline with
582582 /// the assembly.
593593 /// createMachOStreamer - Create a machine code streamer which will generate
594594 /// Mach-O format object files.
595595 ///
596 /// Takes ownership of \arg TAB and \arg CE.
596 /// Takes ownership of \p TAB and \p CE.
597597 MCStreamer *createMachOStreamer(MCContext &Ctx, MCAsmBackend &TAB,
598598 raw_ostream &OS, MCCodeEmitter *CE,
599599 bool RelaxAll = false);
601601 /// createWinCOFFStreamer - Create a machine code streamer which will
602602 /// generate Microsoft COFF format object files.
603603 ///
604 /// Takes ownership of \arg TAB and \arg CE.
604 /// Takes ownership of \p TAB and \p CE.
605605 MCStreamer *createWinCOFFStreamer(MCContext &Ctx,
606606 MCAsmBackend &TAB,
607607 MCCodeEmitter &CE, raw_ostream &OS,
616616 /// createPureStreamer - Create a machine code streamer which will generate
617617 /// "pure" MC object files, for use with MC-JIT and testing tools.
618618 ///
619 /// Takes ownership of \arg TAB and \arg CE.
619 /// Takes ownership of \p TAB and \p CE.
620620 MCStreamer *createPureStreamer(MCContext &Ctx, MCAsmBackend &TAB,
621621 raw_ostream &OS, MCCodeEmitter *CE);
622622
112112 return *Section;
113113 }
114114
115 /// setSection - Mark the symbol as defined in the section \arg S.
115 /// setSection - Mark the symbol as defined in the section \p S.
116116 void setSection(const MCSection &S) { Section = &S; }
117117
118118 /// setUndefined - Mark the symbol as undefined.
148148
149149 /// @}
150150
151 /// print - Print the value to the stream \arg OS.
151 /// print - Print the value to the stream \p OS.
152152 void print(raw_ostream &OS) const;
153153
154154 /// dump - Print the value to stderr.
4444
4545 const Target &getTarget() const { return TheTarget; }
4646
47 /// InstallLexer - Set the lexer to get tokens from lower-level lexer \arg L.
47 /// InstallLexer - Set the lexer to get tokens from lower-level lexer \p L.
4848 void InstallLexer(MCAsmLexer &L) {
4949 Lexer = &L;
5050 }
7676 /// getKind - Get the kind of current token.
7777 AsmToken::TokenKind getKind() const { return CurTok.getKind(); }
7878
79 /// is - Check if the current token has kind \arg K.
79 /// is - Check if the current token has kind \p K.
8080 bool is(AsmToken::TokenKind K) const { return CurTok.is(K); }
8181
82 /// isNot - Check if the current token has kind \arg K.
82 /// isNot - Check if the current token has kind \p K.
8383 bool isNot(AsmToken::TokenKind K) const { return CurTok.isNot(K); }
8484 };
8585
4545 /// isAbsolute - Is this an absolute (as opposed to relocatable) value.
4646 bool isAbsolute() const { return !SymA && !SymB; }
4747
48 /// print - Print the value to the stream \arg OS.
48 /// print - Print the value to the stream \p OS.
4949 void print(raw_ostream &OS, const MCAsmInfo *MAI) const;
5050
5151 /// dump - Print the value to stderr.
169169 }
170170 };
171171
172 /// format - This is a helper function that is used to produce formatted output.
173 /// This is typically used like: OS << format("%0.4f", myfloat) << '\n';
172 /// This is a helper function that is used to produce formatted output.
173 ///
174 /// This is typically used like:
175 /// \code
176 /// OS << format("%0.4f", myfloat) << '\n';
177 /// \endcode
174178 template
175179 inline format_object1 format(const char *Fmt, const T &Val) {
176180 return format_object1(Fmt, Val);
177181 }
178182
179 /// format - This is a helper function that is used to produce formatted output.
180 /// This is typically used like: OS << format("%0.4f", myfloat) << '\n';
183 /// This is a helper function that is used to produce formatted output.
184 ///
185 /// This is typically used like:
186 /// \code
187 /// OS << format("%0.4f", myfloat) << '\n';
188 /// \endcode
181189 template
182190 inline format_object2 format(const char *Fmt, const T1 &Val1,
183191 const T2 &Val2) {
184192 return format_object2(Fmt, Val1, Val2);
185193 }
186194
187 /// format - This is a helper function that is used to produce formatted output.
188 /// This is typically used like: OS << format("%0.4f", myfloat) << '\n';
195 /// This is a helper function that is used to produce formatted output.
196 ///
197 /// This is typically used like:
198 /// \code
199 /// OS << format("%0.4f", myfloat) << '\n';
200 /// \endcode
189201 template
190202 inline format_object3 format(const char *Fmt, const T1 &Val1,
191203 const T2 &Val2, const T3 &Val3) {
192204 return format_object3(Fmt, Val1, Val2, Val3);
193205 }
194206
195 /// format - This is a helper function that is used to produce formatted output.
196 /// This is typically used like: OS << format("%0.4f", myfloat) << '\n';
207 /// This is a helper function that is used to produce formatted output.
208 ///
209 /// This is typically used like:
210 /// \code
211 /// OS << format("%0.4f", myfloat) << '\n';
212 /// \endcode
197213 template
198214 inline format_object4 format(const char *Fmt, const T1 &Val1,
199215 const T2 &Val2, const T3 &Val3,
201217 return format_object4(Fmt, Val1, Val2, Val3, Val4);
202218 }
203219
204 /// format - This is a helper function that is used to produce formatted output.
205 /// This is typically used like: OS << format("%0.4f", myfloat) << '\n';
220 /// This is a helper function that is used to produce formatted output.
221 ///
222 /// This is typically used like:
223 /// \code
224 /// OS << format("%0.4f", myfloat) << '\n';
225 /// \endcode
206226 template
207227 inline format_object5 format(const char *Fmt,const T1 &Val1,
208228 const T2 &Val2, const T3 &Val3,
3535 Newline=2
3636 };
3737
38 /// Compiles the given POSIX Extended Regular Expression \arg Regex.
38 /// Compiles the given POSIX Extended Regular Expression \p Regex.
3939 /// This implementation supports regexes and matching strings with embedded
4040 /// NUL characters.
4141 Regex(StringRef Regex, unsigned Flags = NoFlags);
5050 /// many entries plus one for the whole regex (as element 0).
5151 unsigned getNumMatches() const;
5252
53 /// matches - Match the regex against a given \arg String.
53 /// matches - Match the regex against a given \p String.
5454 ///
5555 /// \param Matches - If given, on a successful match this will be filled in
56 /// with references to the matched group expressions (inside \arg String),
56 /// with references to the matched group expressions (inside \p String),
5757 /// the first group is always the entire pattern.
5858 ///
5959 /// This returns true on a successful match.
6060 bool match(StringRef String, SmallVectorImpl *Matches = 0);
6161
6262 /// sub - Return the result of replacing the first match of the regex in
63 /// \arg String with the \arg Repl string. Backreferences like "\0" in the
63 /// \p String with the \p Repl string. Backreferences like "\0" in the
6464 /// replacement string are replaced with the appropriate match substring.
6565 ///
6666 /// Note that the replacement string has backslash escaping performed on
380380 LastValidFragment[F->getParent()] = F;
381381 }
382382
383 /// WriteFragmentData - Write the \arg F data to the output file.
383 /// WriteFragmentData - Write the \p F data to the output file.
384384 static void WriteFragmentData(const MCAssembler &Asm, const MCAsmLayout &Layout,
385385 const MCFragment &F) {
386386 MCObjectWriter *OW = &Asm.getWriter();
201201 /// This returns true on failure.
202202 bool ProcessIncbinFile(const std::string &Filename);
203203
204 /// \brief Reset the current lexer position to that given by \arg Loc. The
204 /// \brief Reset the current lexer position to that given by \p Loc. The
205205 /// current token is not set; clients should ensure Lex() is called
206206 /// subsequently.
207207 void JumpToLoc(SMLoc Loc);
229229 bool ParseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc);
230230
231231 /// ParseIdentifier - Parse an identifier or string (as a quoted identifier)
232 /// and set \arg Res to the identifier contents.
232 /// and set \p Res to the identifier contents.
233233 virtual bool ParseIdentifier(StringRef &Res);
234234
235235 // Directive Parsing.
2525 return true;
2626 }
2727
28 /// NameNeedsQuoting - Return true if the identifier \arg Str needs quotes to be
28 /// NameNeedsQuoting - Return true if the identifier \p Str needs quotes to be
2929 /// syntactically correct.
3030 static bool NameNeedsQuoting(StringRef Str) {
3131 assert(!Str.empty() && "Cannot create an empty MCSymbol");
144144
145145 /// WriteSegmentLoadCommand - Write a segment load command.
146146 ///
147 /// \arg NumSections - The number of sections in this segment.
148 /// \arg SectionDataSize - The total size of the sections.
147 /// \param NumSections The number of sections in this segment.
148 /// \param SectionDataSize The total size of the sections.
149149 void MachObjectWriter::WriteSegmentLoadCommand(unsigned NumSections,
150150 uint64_t VMSize,
151151 uint64_t SectionDataStartOffset,
121121 DDA.UpdatedSearchState(Changes, Sets, Required);
122122 }
123123
124 /// ExecuteOneTest - Execute a single test predicate on the change set \arg S.
124 /// ExecuteOneTest - Execute a single test predicate on the change set \p S.
125125 bool ExecuteOneTest(const changeset_ty &S) {
126126 // Check dependencies invariant.
127127 DEBUG({
142142
143143 changeset_ty Run();
144144
145 /// GetTestResult - Get the test result for the active set \arg Changes with
146 /// \arg Required changes from the cache, executing the test if necessary.
145 /// GetTestResult - Get the test result for the active set \p Changes with
146 /// \p Required changes from the cache, executing the test if necessary.
147147 ///
148148 /// \param Changes - The set of active changes being minimized, which should
149149 /// have their pred closure included in the test.
304304 }
305305
306306 /// \brief Check whether a particular node is a constant value representable as
307 /// (N * Scale) where (N in [\arg RangeMin, \arg RangeMax).
307 /// (N * Scale) where (N in [\p RangeMin, \p RangeMax).
308308 ///
309309 /// \param ScaledConstant [out] - On success, the pre-scaled constant value.
310310 static bool isScaledConstantInRange(SDValue Node, int Scale,
6666
6767 //! ConstantSDNode predicate for signed 16-bit values
6868 /*!
69 \arg CN The constant SelectionDAG node holding the value
70 \arg Imm The returned 16-bit value, if returning true
69 \param CN The constant SelectionDAG node holding the value
70 \param Imm The returned 16-bit value, if returning true
7171
7272 This predicate tests the value in \a CN to see whether it can be
7373 represented as a 16-bit, sign-extended quantity. Returns true if
304304 }
305305
306306 /*!
307 \arg Op The ISD instruction operand
308 \arg N The address to be tested
309 \arg Base The base address
310 \arg Index The base address index
307 \param Op The ISD instruction operand
308 \param N The address to be tested
309 \param Base The base address
310 \param Index The base address index
311311 */
312312 bool
313313 SPUDAGToDAGISel::SelectAFormAddr(SDNode *Op, SDValue N, SDValue &Base,
374374 }
375375
376376 /*!
377 \arg Op The ISD instruction (ignored)
378 \arg N The address to be tested
379 \arg Base Base address register/pointer
380 \arg Index Base address index
377 \param Op The ISD instruction (ignored)
378 \param N The address to be tested
379 \param Base Base address register/pointer
380 \param Index Base address index
381381
382382 Examine the input address by a base register plus a signed 10-bit
383383 displacement, [r+I10] (D-form address).
540540 }
541541
542542 /*!
543 \arg Op The ISD instruction operand
544 \arg N The address operand
545 \arg Base The base pointer operand
546 \arg Index The offset/index operand
543 \param Op The ISD instruction operand
544 \param N The address operand
545 \param Base The base pointer operand
546 \param Index The offset/index operand
547547
548548 If the address \a N can be expressed as an A-form or D-form address, returns
549549 false. Otherwise, creates two operands, Base and Index that will become the
568568 Utility function to use with COPY_TO_REGCLASS instructions. Returns a SDValue
569569 to be used as the last parameter of a
570570 CurDAG->getMachineNode(COPY_TO_REGCLASS,..., ) function call
571 \arg VT the value type for which we want a register class
571 \param VT the value type for which we want a register class
572572 */
573573 SDValue SPUDAGToDAGISel::getRC( MVT VT ) {
574574 switch( VT.SimpleTy ) {
4343 OutName.push_back('_');
4444 }
4545
46 /// NameNeedsEscaping - Return true if the identifier \arg Str needs quotes
46 /// NameNeedsEscaping - Return true if the identifier \p Str needs quotes
4747 /// for this assembler.
4848 static bool NameNeedsEscaping(StringRef Str, const MCAsmInfo &MAI) {
4949 assert(!Str.empty() && "Cannot create an empty MCSymbol");
9191 MCELFObjectTargetWriter::getOSABI(OSType), IsLittle, Is64Bit);
9292 }
9393
94 /// ApplyFixup - Apply the \arg Value for given \arg Fixup into the provided
94 /// ApplyFixup - Apply the \p Value for given \p Fixup into the provided
9595 /// data fragment, at the offset specified by the fixup and following the
9696 /// fixup kind as appropriate.
9797 void applyFixup(const MCFixup &Fixup, char *Data, unsigned DataSize,
277277 Res.setOpcode(RelaxedOp);
278278 }
279279
280 /// writeNopData - Write optimal nops to the output file for the \arg Count
280 /// writeNopData - Write optimal nops to the output file for the \p Count
281281 /// bytes. This returns the number of bytes written. It may return 0 if
282 /// the \arg Count is more than the maximum optimal nops.
282 /// the \p Count is more than the maximum optimal nops.
283283 bool X86AsmBackend::writeNopData(uint64_t Count, MCObjectWriter *OW) const {
284284 static const uint8_t Nops[10][10] = {
285285 // nop
35493549 }
35503550
35513551 /// OptimizeReturns - Look for this pattern:
3552 ///
3552 /// \code
35533553 /// %call = call i8* @something(...)
35543554 /// %2 = call i8* @objc_retain(i8* %call)
35553555 /// %3 = call i8* @objc_autorelease(i8* %2)
35563556 /// ret i8* %3
3557 ///
3557 /// \endcode
35583558 /// And delete the retain and autorelease.
35593559 ///
35603560 /// Otherwise if it's just this:
3561 ///
3561 /// \code
35623562 /// %3 = call i8* @objc_autorelease(i8* %2)
35633563 /// ret i8* %3
3564 ///
3564 /// \endcode
35653565 /// convert the autorelease to autoreleaseRV.
35663566 void ObjCARCOpt::OptimizeReturns(Function &F) {
35673567 if (!F.getReturnType()->isPointerTy())