llvm.org GIT mirror llvm / 217b38e
Fix typos in comments, NFC Summary: Just fixing comments, no functional change. Test Plan: N/A Reviewers: jfb Subscribers: mcrosier, llvm-commits Differential Revision: http://reviews.llvm.org/D5130 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@216784 91177308-0d34-0410-b5e6-96231b3b80d8 Robin Morisset 6 years ago
25 changed file(s) with 26 addition(s) and 28 deletion(s). Raw diff Collapse all Expand all
872872 llvm/ADT/ilist_node.h
873873 ^^^^^^^^^^^^^^^^^^^^^
874874
875 ``ilist_node`` implements a the forward and backward links that are expected
875 ``ilist_node`` implements the forward and backward links that are expected
876876 by the ``ilist`` (and analogous containers) in the default manner.
877877
878878 ``ilist_node``\ s are meant to be embedded in the node type ``T``, usually
536536
537537 static void *ID() { return (void *)&PassID; }
538538
539 /// \brief Compute the \c LazyCallGraph for a the module \c M.
539 /// \brief Compute the \c LazyCallGraph for the module \c M.
540540 ///
541541 /// This just builds the set of entry points to the call graph. The rest is
542542 /// built lazily as it is walked.
1818 namespace llvm {
1919
2020 /// PostDominatorTree Class - Concrete subclass of DominatorTree that is used to
21 /// compute the a post-dominator tree.
21 /// compute the post-dominator tree.
2222 ///
2323 struct PostDominatorTree : public FunctionPass {
2424 static char ID; // Pass identification, replacement for typeid
182182 /// should probably move to simpler cost metrics using the above.
183183 /// Alternatively, we could split the cost interface into distinct code-size
184184 /// and execution-speed costs. This would allow modelling the core of this
185 /// query more accurately as the a call is a single small instruction, but
185 /// query more accurately as a call is a single small instruction, but
186186 /// incurs significant execution cost.
187187 virtual bool isLoweredToCall(const Function *F) const;
188188
2121
2222 ///
2323 /// PostDominatorTree Class - Concrete subclass of DominatorTree that is used
24 /// to compute the a post-dominator tree.
24 /// to compute the post-dominator tree.
2525 ///
2626 struct MachinePostDominatorTree : public MachineFunctionPass {
2727 private:
748748 SDValue SV, unsigned Align);
749749
750750 /// getAtomicCmpSwap - Gets a node for an atomic cmpxchg op. There are two
751 /// valid Opcodes. ISD::ATOMIC_CMO_SWAP produces a the value loaded and a
751 /// valid Opcodes. ISD::ATOMIC_CMO_SWAP produces the value loaded and a
752752 /// chain result. ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS produces the value loaded,
753753 /// a success flag (initially i1), and a chain.
754754 SDValue getAtomicCmpSwap(unsigned Opcode, SDLoc dl, EVT MemVT, SDVTList VTs,
445445 /// The first template argument handles whether or not to preserve names in the
446446 /// final instruction output. This defaults to on. The second template argument
447447 /// specifies a class to use for creating constants. This defaults to creating
448 /// minimally folded constants. The fourth template argument allows clients to
448 /// minimally folded constants. The third template argument allows clients to
449449 /// specify custom insertion hooks that are called on every newly created
450450 /// insertion.
451451 template
134134 return getSubclassDataFromInstruction() & 32;
135135 }
136136
137 /// \brief Specify whether this alloca is used to represent a the arguments to
137 /// \brief Specify whether this alloca is used to represent the arguments to
138138 /// a call.
139139 void setUsedWithInAlloca(bool V) {
140140 setInstructionSubclassData((getSubclassDataFromInstruction() & ~32) |
322322 }
323323
324324 /// getContainedType - This method is used to implement the type iterator
325 /// (defined a the end of the file). For derived types, this returns the
325 /// (defined at the end of the file). For derived types, this returns the
326326 /// types 'contained' in the derived type.
327327 ///
328328 Type *getContainedType(unsigned i) const {
8686 bool HasMachoTBSSDirective;
8787
8888 /// True if the compiler should emit a ".reference .constructors_used" or
89 /// ".reference .destructors_used" directive after the a static ctor/dtor
89 /// ".reference .destructors_used" directive after the static ctor/dtor
9090 /// list. This directive is only emitted in Static relocation model. Default
9191 /// is false.
9292 bool HasStaticCtorDtorReferenceInStaticMode;
936936 return Dep;
937937 }
938938
939 /// SortNonLocalDepInfoCache - Sort the a NonLocalDepInfo cache, given a certain
939 /// SortNonLocalDepInfoCache - Sort the NonLocalDepInfo cache, given a certain
940940 /// number of elements in the array that are already properly ordered. This is
941941 /// optimized for the case when only a few entries are added.
942942 static void
125125 // Normalized form: {-2,+,1,+,2}
126126 // Denormalized form: {1,+,3,+,2}
127127 //
128 // However, denormalization would use the a different step expression than
128 // However, denormalization would use a different step expression than
129129 // normalization (see getPostIncExpr), generating the wrong final
130130 // expression: {-2,+,1,+,2} + {1,+,2} => {-1,+,3,+,2}
131131 if (AR->isAffine() &&
33363336 if (isDefine)
33373337 return false;
33383338
3339 // Check the a declaration has no block address forward references.
3339 // Check the declaration has no block address forward references.
33403340 ValID ID;
33413341 if (FunctionName.empty()) {
33423342 ID.Kind = ValID::t_GlobalID;
260260 return;
261261 }
262262
263 // otherwise, b) use the letter 'T' as a the marker, ...
263 // otherwise, b) use the letter 'T' as the marker, ...
264264 addULEB128('T');
265265
266266 addULEB128(Attribute);
227227 unsigned StackColoring::collectMarkers(unsigned NumSlot) {
228228 unsigned MarkersFound = 0;
229229 // Scan the function to find all lifetime markers.
230 // NOTE: We use the a reverse-post-order iteration to ensure that we obtain a
230 // NOTE: We use a reverse-post-order iteration to ensure that we obtain a
231231 // deterministic numbering, and because we'll need a post-order iteration
232232 // later for solving the liveness dataflow problem.
233233 for (MachineBasicBlock *MBB : depth_first(MF)) {
679679 bool DefaultJITMemoryManager::CheckInvariants(std::string &ErrorStr) {
680680 raw_string_ostream Err(ErrorStr);
681681
682 // Construct a the set of FreeRangeHeader pointers so we can query it
682 // Construct the set of FreeRangeHeader pointers so we can query it
683683 // efficiently.
684684 llvm::SmallPtrSet FreeHdrSet;
685685 FreeRangeHeader* FreeHead = FreeMemoryList;
66 //
77 //===----------------------------------------------------------------------===//
88 //
9 // This file defines the a diagnostic printer relying on raw_ostream.
9 // This file defines a diagnostic printer relying on raw_ostream.
1010 //
1111 //===----------------------------------------------------------------------===//
1212
302302
303303 /// \brief Determine wether it is worth to fold V into an extended register.
304304 bool AArch64DAGToDAGISel::isWorthFolding(SDValue V) const {
305 // it hurts if the a value is used at least twice, unless we are optimizing
305 // it hurts if the value is used at least twice, unless we are optimizing
306306 // for code size.
307307 if (ForCodeSize || V.hasOneUse())
308308 return true;
17801780
17811781 #include "AArch64GenCallingConv.inc"
17821782
1783 /// Selects the correct CCAssignFn for a the given CallingConvention
1784 /// value.
1783 /// Selects the correct CCAssignFn for a given CallingConvention value.
17851784 CCAssignFn *AArch64TargetLowering::CCAssignFnForCall(CallingConv::ID CC,
17861785 bool IsVarArg) const {
17871786 switch (CC) {
198198 public:
199199 explicit AArch64TargetLowering(TargetMachine &TM);
200200
201 /// Selects the correct CCAssignFn for a the given CallingConvention
202 /// value.
201 /// Selects the correct CCAssignFn for a given CallingConvention value.
203202 CCAssignFn *CCAssignFnForCall(CallingConv::ID CC, bool IsVarArg) const;
204203
205204 /// computeKnownBitsForTargetNode - Determine which of the bits specified in
28882888 // FIXME: The current MachineInstr design does not support relying on machine
28892889 // mem operands to determine the width of a memory access. Instead, we expect
28902890 // the target to provide this information based on the instruction opcode and
2891 // operands. However, using MachineMemOperand is a the best solution now for
2891 // operands. However, using MachineMemOperand is the best solution now for
28922892 // two reasons:
28932893 //
28942894 // 1) getNumMicroOps tries to infer LDM memory width from the total number of MI
17701770
17711771 //
17721772 // For constants, llvm transforms this to:
1773 // x > (k -1) and then reverses the operands to use setlt. So this pattern
1773 // x > (k - 1) and then reverses the operands to use setlt. So this pattern
17741774 // is not used now by the compiler. (Presumably checking that k-1 does not
1775 // overflow). The compiler never uses this at a the current time, due to
1775 // overflow). The compiler never uses this at the current time, due to
17761776 // other optimizations.
17771777 //
17781778 //def: Mips16Pat
55 ; we may reference variables that were not live across basic blocks
66 ; resulting in undefined virtual registers.
77 ;
8 ; In this example, this is illustrated by a the spill/reload of the
8 ; In this example, this is illustrated by a spill/reload of the
99 ; LOADED_PTR_SLOT.
1010 ;
1111 ; Before this patch, the compiler was accessing two different spill
0 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o - | llvm-readobj -s -t | FileCheck %s
11
2 // Test that we produce the group sections and that they are a the beginning
2 // Test that we produce the group sections and that they are at the beginning
33 // of the file.
44
55 // CHECK: Section {
184184 /// Conceptually, we'd like to sink these predicates all the way to the last
185185 /// matcher predicate in the series. However, it turns out that some
186186 /// ComplexPatterns have side effects on the graph, so we really don't want to
187 /// run a the complex pattern if the pattern predicate will fail. For this
187 /// run a complex pattern if the pattern predicate will fail. For this
188188 /// reason, we refuse to sink the pattern predicate past a ComplexPattern.
189189 ///
190190 static void SinkPatternPredicates(std::unique_ptr &MatcherPtr) {