llvm.org GIT mirror llvm / 8040eab
[NFC] fix trivial typos in comments and documents "in in" -> "in", "on on" -> "on" etc. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@323508 91177308-0d34-0410-b5e6-96231b3b80d8 Hiroshi Inoue 1 year, 6 months ago
23 changed file(s) with 24 addition(s) and 24 deletion(s). Raw diff Collapse all Expand all
18711871 // See llvm::FunctionPassManager::run(Function&).
18721872 func (pm PassManager) RunFunc(f Value) bool { return C.LLVMRunFunctionPassManager(pm.C, f.C) != 0 }
18731873
1874 // Finalizes all of the function passes scheduled in in the function pass
1874 // Finalizes all of the function passes scheduled in the function pass
18751875 // manager. Returns 1 if any of the passes modified the module, 0 otherwise.
18761876 // See llvm::FunctionPassManager::doFinalization.
18771877 func (pm PassManager) FinalizeFunc() bool { return C.LLVMFinalizeFunctionPassManager(pm.C) != 0 }
26182618 See the [llvm::FunctionPassManager::run] method. *)
26192619 val run_function : llvalue -> [ `Function ] t -> bool
26202620
2621 (** [finalize fpm] finalizes all of the function passes scheduled in in the
2621 (** [finalize fpm] finalizes all of the function passes scheduled in the
26222622 function pass manager [fpm]. Returns [true] if any of the passes
26232623 modified the module, [false] otherwise.
26242624 See the [llvm::FunctionPassManager::doFinalization] method. *)
911911 cross-compiling CMake provides a variable ``CMAKE_TOOLCHAIN_FILE`` which can
912912 define compiler flags and variables used during the CMake test operations.
913913
914 The result of such a build is executables that are not runnable on on the build
914 The result of such a build is executables that are not runnable on the build
915915 host but can be executed on the target. As an example the following CMake
916916 invocation can generate build files targeting iOS. This will work on Mac OS X
917917 with the latest Xcode:
7878 operands of a given ``MemoryAccess`` are all (potential) clobbers of said
7979 MemoryAccess, and the value produced by a ``MemoryAccess`` can act as a clobber
8080 for other ``MemoryAccess``\ es. Another useful way of looking at it is in
81 terms of heap versions. In that view, operands of of a given
81 terms of heap versions. In that view, operands of a given
8282 ``MemoryAccess`` are the version of the heap before the operation, and
8383 if the access produces a value, the value is the new version of the heap
8484 after the operation.
284284
285285 # When enabled doxygen tries to link words that correspond to documented
286286 # classes, or namespaces to their corresponding documentation. Such a link can
287 # be prevented in individual cases by by putting a % sign in front of the word
287 # be prevented in individual cases by putting a % sign in front of the word
288288 # or globally by setting AUTOLINK_SUPPORT to NO.
289289 # The default value is: YES.
290290
192192
193193 ``Lexer.lex`` works by recursing over a ``char Stream.t`` to read
194194 characters one at a time from the standard input. It eats them as it
195 recognizes them and stores them in in a ``Token.token`` variant. The
195 recognizes them and stores them in a ``Token.token`` variant. The
196196 first thing that it has to do is ignore whitespace between tokens. This
197197 is accomplished with the recursive call above.
198198
307307 /// compared to the same memory location accessed through a pointer with a
308308 /// different address space.
309309 //
310 /// This is for for targets with different pointer representations which can
310 /// This is for targets with different pointer representations which can
311311 /// be converted with the addrspacecast instruction. If a pointer is converted
312312 /// to this address space, optimizations should attempt to replace the access
313313 /// with the source address space.
462462
463463 // In a MachO file, sections have a segment name. This is used in the .o
464464 // files. They have a single segment, but this field specifies which segment
465 // a section should be put in in the final object.
465 // a section should be put in the final object.
466466 StringRef getSectionFinalSegmentName(DataRefImpl Sec) const;
467467
468468 // Names are stored as 16 bytes. These returns the raw 16 bytes without
31853185 @see llvm::FunctionPassManager::run(Function&) */
31863186 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
31873187
3188 /** Finalizes all of the function passes scheduled in in the function pass
3188 /** Finalizes all of the function passes scheduled in the function pass
31893189 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
31903190 @see llvm::FunctionPassManager::doFinalization */
31913191 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
111111
112112 virtual void emitTypeInfos(unsigned TTypeEncoding);
113113
114 // Helpers for for identifying what kind of clause an EH typeid or selector
114 // Helpers for identifying what kind of clause an EH typeid or selector
115115 // corresponds to. Negative selectors are for filter clauses, the zero
116116 // selector is for cleanups, and positive selectors are for catch clauses.
117117 static bool isFilterEHSelector(int Selector) { return Selector < 0; }
133133 // The block branched to if the pointer is null.
134134 MachineBasicBlock *NullSucc;
135135
136 // If this is non-null, then MemOperation has a dependency on on this
136 // If this is non-null, then MemOperation has a dependency on this
137137 // instruction; and it needs to be hoisted to execute before MemOperation.
138138 MachineInstr *OnlyDependency;
139139
11511151 if (C1.getStartIdx() > MaxCandidateLen)
11521152 FarthestPossibleIdx = C1.getStartIdx() - MaxCandidateLen;
11531153
1154 // Compare against the candidates in the list that start at at most
1154 // Compare against the candidates in the list that start at most
11551155 // FarthestPossibleIdx indices away from C1. There are at most
11561156 // MaxCandidateLen of these.
11571157 for (auto Sit = It + 1; Sit != Et; Sit++) {
34323432 // low lanes.
34333433 switch (N->getOpcode()) {
34343434 default:
3435 llvm_unreachable("Extend legalization on on extend operation!");
3435 llvm_unreachable("Extend legalization on extend operation!");
34363436 case ISD::ANY_EXTEND:
34373437 return DAG.getAnyExtendVectorInReg(InOp, DL, VT);
34383438 case ISD::SIGN_EXTEND:
621621 // operand may be a subregister of a larger register, while Bits would
622622 // correspond to the larger register in its entirety. Because of that,
623623 // the parameter Begin can be used to indicate which bit of Bits should be
624 // considered the LSB of of the operand.
624 // considered the LSB of the operand.
625625 bool HexagonBitSimplify::getUsedBits(unsigned Opc, unsigned OpN,
626626 BitVector &Bits, uint16_t Begin, const HexagonInstrInfo &HII) {
627627 using namespace Hexagon;
11691169 }
11701170 case HexagonISD::JT:
11711171 case HexagonISD::CP:
1172 // These are assumed to always be aligned at at least 8-byte boundary.
1172 // These are assumed to always be aligned at least 8-byte boundary.
11731173 if (LogAlign > 3)
11741174 return false;
11751175 R = N.getOperand(0);
11811181 R = N;
11821182 return true;
11831183 case ISD::BlockAddress:
1184 // Block address is always aligned at at least 4-byte boundary.
1184 // Block address is always aligned at least 4-byte boundary.
11851185 if (LogAlign > 2 || !IsAligned(cast(N)->getOffset()))
11861186 return false;
11871187 R = N;
229229 // Move the vector predicate SubV to a vector register, and scale it
230230 // down to match the representation (bytes per type element) that VecV
231231 // uses. The scaling down will pick every 2nd or 4th (every Scale-th
232 // in general) element and put them at at the front of the resulting
232 // in general) element and put them at the front of the resulting
233233 // vector. This subvector will then be inserted into the Q2V of VecV.
234234 // To avoid having an operation that generates an illegal type (short
235235 // vector), generate a full size vector.
14231423 // setcc instead and earlier I had implemented setcc first so may have masked
14241424 // the problem. The setcc variants are suboptimal for mips16 so I may wantto
14251425 // figure out how to enable the brcond patterns or else possibly new
1426 // combinations of of brcond and setcc.
1426 // combinations of brcond and setcc.
14271427 //
14281428 //
14291429 // bcond-seteq
135135 MachineBasicBlock *Header = Loop ? Loop->getHeader() : &*MF.begin();
136136 SetVector RewriteSuccs;
137137
138 // DFS through Loop's body, looking for for irreducible control flow. Loop is
138 // DFS through Loop's body, looking for irreducible control flow. Loop is
139139 // natural, and we stay in its body, and we treat any nested loops
140140 // monolithically, so any cycles we encounter indicate irreducibility.
141141 SmallPtrSet OnStack;
30653065
30663066
30673067
3068 // Various unary fpstack operations default to operating on on ST1.
3068 // Various unary fpstack operations default to operating on ST1.
30693069 // For example, "fxch" -> "fxch %st(1)"
30703070 def : InstAlias<"faddp", (ADD_FPrST0 ST1), 0>;
30713071 def: InstAlias<"fadd", (ADD_FPrST0 ST1), 0>;
557557
558558 // The guard condition is expected to be in form of:
559559 // cond1 && cond2 && cond3 ...
560 // Iterate over subconditions looking for for icmp conditions which can be
560 // Iterate over subconditions looking for icmp conditions which can be
561561 // widened across loop iterations. Widening these conditions remember the
562562 // resulting list of subconditions in Checks vector.
563563 SmallVector Worklist(1, Guard->getOperand(0));
796796 uint64_t Size = DL.getTypeStoreSize(ValOp->getType());
797797
798798 // If this memory access can be shown to *statically* extend outside the
799 // bounds of of the allocation, it's behavior is undefined, so simply
799 // bounds of the allocation, it's behavior is undefined, so simply
800800 // ignore it. Note that this is more strict than the generic clamping
801801 // behavior of insertUse. We also try to handle cases which might run the
802802 // risk of overflow.
369369
370370 /// A helper function that returns the reciprocal of the block probability of
371371 /// predicated blocks. If we return X, we are assuming the predicated block
372 /// will execute once for for every X iterations of the loop header.
372 /// will execute once for every X iterations of the loop header.
373373 ///
374374 /// TODO: We should use actual block probability here, if available. Currently,
375375 /// we always assume predicated blocks have a 50% chance of executing.
22 ; RUN: llc -verify-machineinstrs -mcpu=pwr9 -O2 -fast-isel=false -mattr=+vsx < %s | FileCheck -check-prefix=CHECK-P9 %s
33
44 ; Verify internal alignment of long double in a struct. The double
5 ; argument comes in in GPR3; GPR4 is skipped; GPRs 5 and 6 contain
5 ; argument comes in GPR3; GPR4 is skipped; GPRs 5 and 6 contain
66 ; the long double. Check that these are stored to proper locations
77 ; in the parameter save area and loaded from there for return in FPR1/2.
88