llvm.org GIT mirror llvm / f451cb8
Fix "the the" and similar typos. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@95781 91177308-0d34-0410-b5e6-96231b3b80d8 Dan Gohman 10 years ago
59 changed file(s) with 67 addition(s) and 67 deletion(s). Raw diff Collapse all Expand all
7171 // free Call Utility Functions.
7272 //
7373
74 /// isFreeCall - Returns true if the the value is a call to the builtin free()
74 /// isFreeCall - Returns true if the value is a call to the builtin free()
7575 bool isFreeCall(const Value *I);
7676
7777 } // End llvm namespace
290290 /// EmitRecordWithAbbrevImpl - This is the core implementation of the record
291291 /// emission code. If BlobData is non-null, then it specifies an array of
292292 /// data that should be emitted as part of the Blob or Array operand that is
293 /// known to exist at the end of the the record.
293 /// known to exist at the end of the record.
294294 template
295295 void EmitRecordWithAbbrevImpl(unsigned Abbrev, SmallVectorImpl &Vals,
296296 StringRef Blob) {
145145 }
146146 }
147147
148 /// emitAlignment - Move the CurBufferPtr pointer up the the specified
148 /// emitAlignment - Move the CurBufferPtr pointer up the specified
149149 /// alignment (saturated to BufferEnd of course).
150150 void emitAlignment(unsigned Alignment) {
151151 if (Alignment == 0) Alignment = 1;
319319 /// advanceTo - Advance the specified iterator to point to the LiveRange
320320 /// containing the specified position, or end() if the position is past the
321321 /// end of the interval. If no LiveRange contains this position, but the
322 /// position is in a hole, this method returns an iterator pointing the the
322 /// position is in a hole, this method returns an iterator pointing the
323323 /// LiveRange immediately after the hole.
324324 iterator advanceTo(iterator I, SlotIndex Pos) {
325325 if (Pos >= endIndex())
154154 }
155155 }
156156
157 /// emitAlignment - Move the CurBufferPtr pointer up the the specified
157 /// emitAlignment - Move the CurBufferPtr pointer up the specified
158158 /// alignment (saturated to BufferEnd of course).
159159 void emitAlignment(unsigned Alignment) {
160160 if (Alignment == 0) Alignment = 1;
135135 : TD(td), PoolAlignment(1) {}
136136 ~MachineConstantPool();
137137
138 /// getConstantPoolAlignment - Return the the alignment required by
138 /// getConstantPoolAlignment - Return the alignment required by
139139 /// the whole constant pool, of which the first element must be aligned.
140140 unsigned getConstantPoolAlignment() const { return PoolAlignment; }
141141
329329 bool NoImp = false);
330330
331331 /// CloneMachineInstr - Create a new MachineInstr which is a copy of the
332 /// 'Orig' instruction, identical in all ways except the the instruction
332 /// 'Orig' instruction, identical in all ways except the instruction
333333 /// has no parent, prev, or next.
334334 ///
335335 /// See also TargetInstrInfo::duplicate() for target-specific fixes to cloned
346346
347347 /// isInvariantLoad - Return true if this instruction is loading from a
348348 /// location whose value is invariant across the function. For example,
349 /// loading a value from the constant pool or from from the argument area of
349 /// loading a value from the constant pool or from the argument area of
350350 /// a function if it does not change. This should only return true of *all*
351351 /// loads the instruction does are invariant (if it does multiple loads).
352352 bool isInvariantLoad(AliasAnalysis *AA) const;
8080 /// written to the data stream in big-endian format.
8181 void emitDWordBE(uint64_t W);
8282
83 /// emitAlignment - Move the CurBufferPtr pointer up the the specified
83 /// emitAlignment - Move the CurBufferPtr pointer up the specified
8484 /// alignment (saturated to BufferEnd of course).
8585 void emitAlignment(unsigned Alignment = 0, uint8_t fill = 0);
8686
9191 void setSection(StringRef S) { Section = S; }
9292
9393 /// If the usage is empty (except transitively dead constants), then this
94 /// global value can can be safely deleted since the destructor will
94 /// global value can be safely deleted since the destructor will
9595 /// delete the dead constants as well.
9696 /// @brief Determine if the usage of this global value is empty except
9797 /// for transitively dead constants.
3838 virtual ~InlineAsm();
3939 public:
4040
41 /// InlineAsm::get - Return the the specified uniqued inline asm string.
41 /// InlineAsm::get - Return the specified uniqued inline asm string.
4242 ///
4343 static InlineAsm *get(const FunctionType *Ty, StringRef AsmString,
4444 StringRef Constraints, bool hasSideEffects,
147147 getAllMetadataImpl(MDs);
148148 }
149149
150 /// setMetadata - Set the metadata of of the specified kind to the specified
150 /// setMetadata - Set the metadata of the specified kind to the specified
151151 /// node. This updates/replaces metadata if already present, or removes it if
152152 /// Node is null.
153153 void setMetadata(unsigned KindID, MDNode *Node);
222222 /// the archive that resolve outstanding symbols will be linked in. The
223223 /// library is searched repeatedly until no more modules that resolve
224224 /// symbols can be found. If an error occurs, the error string is set.
225 /// To speed up this function, ensure the the archive has been processed
225 /// To speed up this function, ensure the archive has been processed
226226 /// llvm-ranlib or the S option was given to llvm-ar when the archive was
227227 /// created. These tools add a symbol table to the archive which makes the
228228 /// search for undefined symbols much faster.
8888 return !isDefined();
8989 }
9090
91 /// isAbsolute - Check if this this is an absolute symbol.
91 /// isAbsolute - Check if this is an absolute symbol.
9292 bool isAbsolute() const {
9393 return Section == AbsolutePseudoSection;
9494 }
393393 const AnalysisUsage::VectorType &Set) const;
394394
395395 // Set of available Analysis. This information is used while scheduling
396 // pass. If a pass requires an analysis which is not not available then
397 // equired analysis pass is scheduled to run before the pass itself is
396 // pass. If a pass requires an analysis which is not available then
397 // the required analysis pass is scheduled to run before the pass itself is
398398 // scheduled to run.
399399 std::map AvailableAnalysis;
400400
9393 //===--------------------------------------------------------------------===//
9494
9595 /// CreateGlobalString - Make a new global variable with an initializer that
96 /// has array of i8 type filled in the the nul terminated string value
96 /// has array of i8 type filled in the nul terminated string value
9797 /// specified. If Name is specified, it is the name of the global variable
9898 /// created.
9999 Value *CreateGlobalString(const char *Str = "", const Twine &Name = "");
2222 /// might be known as shared libraries, shared objects, dynamic shared
2323 /// objects, or dynamic link libraries. Regardless of the terminology or the
2424 /// operating system interface, this class provides a portable interface that
25 /// allows dynamic libraries to be loaded and and searched for externally
25 /// allows dynamic libraries to be loaded and searched for externally
2626 /// defined symbols. This is typically used to provide "plug-in" support.
2727 /// It also allows for symbols to be defined which don't live in any library,
2828 /// but rather the main program itself, useful on Windows where the main
2727 /// platform independent and eliminates many of the unix-specific fields.
2828 /// However, to support llvm-ar, the mode, user, and group fields are
2929 /// retained. These pertain to unix security and may not have a meaningful
30 /// value on non-Unix platforms. However, the other fields fields should
30 /// value on non-Unix platforms. However, the other fields should
3131 /// always be applicable on all platforms. The structure is filled in by
3232 /// the PathWithStatus class.
3333 /// @brief File status structure
375375
376376
377377 // InstrInfo - This class should only be instantiated once to provide parameters
378 // which are global to the the target machine.
378 // which are global to the target machine.
379379 //
380380 class InstrInfo {
381381 // If the target wants to associate some target-specific information with each
168168 return I;
169169 }
170170
171 /// hasSubClass - return true if the the specified TargetRegisterClass
171 /// hasSubClass - return true if the specified TargetRegisterClass
172172 /// is a proper subset of this TargetRegisterClass.
173173 bool hasSubClass(const TargetRegisterClass *cs) const {
174174 for (int i = 0; SubClasses[i] != NULL; ++i)
485485 if (GV1 && !NonAddressTakenGlobals.count(GV1)) GV1 = 0;
486486 if (GV2 && !NonAddressTakenGlobals.count(GV2)) GV2 = 0;
487487
488 // If the the two pointers are derived from two different non-addr-taken
488 // If the two pointers are derived from two different non-addr-taken
489489 // globals, or if one is and the other isn't, we know these can't alias.
490490 if ((GV1 || GV2) && GV1 != GV2)
491491 return NoAlias;
183183 }
184184 }
185185
186 // If the value was never used outside the the block in which it was
186 // If the value was never used outside the block in which it was
187187 // defined, it's killed in that block.
188188 if (!LiveOutOfDefBB)
189189 M.Killed.insert(DefBB);
2323 // malloc Call Utility Functions.
2424 //
2525
26 /// isMalloc - Returns true if the the value is either a malloc call or a
26 /// isMalloc - Returns true if the value is either a malloc call or a
2727 /// bitcast of the result of a malloc call.
2828 bool llvm::isMalloc(const Value *I) {
2929 return extractMallocCall(I) || extractMallocCallFromBitCast(I);
182182 // free Call Utility Functions.
183183 //
184184
185 /// isFreeCall - Returns true if the the value is a call to the builtin free()
185 /// isFreeCall - Returns true if the value is a call to the builtin free()
186186 bool llvm::isFreeCall(const Value *I) {
187187 const CallInst *CI = dyn_cast(I);
188188 if (!CI)
50315031 if (Step->isOne()) {
50325032 // With unit stride, the iteration never steps past the limit value.
50335033 } else if (isKnownPositive(Step)) {
5034 // Test whether a positive iteration iteration can step past the limit
5034 // Test whether a positive iteration can step past the limit
50355035 // value and past the maximum value for its type in a single step.
50365036 // Note that it's not sufficient to check NoWrap here, because even
50375037 // though the value after a wrap is undefined, it's not undefined
301301 OutStreamer.GetCommentOS() << '\n';
302302 }
303303
304 // Emit the CurrentFnSym. This is is a virtual function to allow targets to
304 // Emit the CurrentFnSym. This is a virtual function to allow targets to
305305 // do their wild and crazy things as required.
306306 EmitFunctionEntryLabel();
307307
617617
618618 1). Add the offset of the forwarding field.
619619
620 2). Follow that pointer to get the the real __Block_byref_x_VarName
620 2). Follow that pointer to get the real __Block_byref_x_VarName
621621 struct to use (the real one may have been copied onto the heap).
622622
623623 3). Add the offset for the field VarName, to find the actual variable.
102102 ///
103103 SmallVector, 8> SourceIds;
104104
105 /// Lines - List of of source line correspondence.
105 /// Lines - List of source line correspondence.
106106 std::vector Lines;
107107
108108 /// DIEValues - A list of all the unique values in use.
102102 /// exception. If it matches then the exception and type id are passed
103103 /// on to the landing pad. Otherwise the next action is looked up. This
104104 /// chain is terminated with a next action of zero. If no type id is
105 /// found the the frame is unwound and handling continues.
105 /// found the frame is unwound and handling continues.
106106 /// 3. Type id table contains references to all the C++ typeinfo for all
107107 /// catches in the function. This tables is reversed indexed base 1.
108108
114114 // Ask the target's AnalyzeBranch if it can handle this block.
115115 MachineBasicBlock *TBB = 0, *FBB = 0;
116116 SmallVector Cond;
117 // Make the the terminator is understood.
117 // Make the terminator is understood.
118118 if (TII->AnalyzeBranch(*MBB, TBB, FBB, Cond))
119119 return false;
120120 // Make sure we have the option of reversing the condition.
66 //
77 //===----------------------------------------------------------------------===//
88 //
9 // This implements a a hazard recognizer using the instructions itineraries
9 // This implements a hazard recognizer using the instructions itineraries
1010 // defined for the current target.
1111 //
1212 //===----------------------------------------------------------------------===//
186186 }
187187
188188 /// CloneMachineInstr - Create a new MachineInstr which is a copy of the
189 /// 'Orig' instruction, identical in all ways except the the instruction
189 /// 'Orig' instruction, identical in all ways except the instruction
190190 /// has no parent, prev, or next.
191191 ///
192192 MachineInstr *
10331033
10341034 /// isInvariantLoad - Return true if this instruction is loading from a
10351035 /// location whose value is invariant across the function. For example,
1036 /// loading a value from the constant pool or from from the argument area
1036 /// loading a value from the constant pool or from the argument area
10371037 /// of a function if it does not change. This should only return true of
10381038 /// *all* loads the instruction does are invariant (if it does multiple loads).
10391039 bool MachineInstr::isInvariantLoad(AliasAnalysis *AA) const {
88 //
99 // Heuristic PBQP solver. This solver is able to perform optimal reductions for
1010 // nodes of degree 0, 1 or 2. For nodes of degree >2 a plugable heuristic is
11 // used to to select a node for reduction.
11 // used to select a node for reduction.
1212 //
1313 //===----------------------------------------------------------------------===//
1414
26392639
26402640 // If the shift is not a no-op (in which case this should be just a sign
26412641 // extend already), the truncated to type is legal, sign_extend is legal
2642 // on that type, and the the truncate to that type is both legal and free,
2642 // on that type, and the truncate to that type is both legal and free,
26432643 // perform the transform.
26442644 if ((ShiftAmt > 0) &&
26452645 TLI.isOperationLegalOrCustom(ISD::SIGN_EXTEND, TruncVT) &&
27662766 DAG.getIntPtrConstant(1));
27672767 } else {
27682768 // FIXME: We should be able to fall back to a libcall with an illegal
2769 // type in some cases cases.
2769 // type in some cases.
27702770 // Also, we can fall back to a division in some cases, but that's a big
27712771 // performance hit in the general case.
27722772 llvm_unreachable("Don't know how to expand this operation yet!");
13481348 DAG.getConstant(JTH.First, VT));
13491349
13501350 // The SDNode we just created, which holds the value being switched on minus
1351 // the the smallest case value, needs to be copied to a virtual register so it
1351 // the smallest case value, needs to be copied to a virtual register so it
13521352 // can be used as an index into the jump table in a subsequent basic block.
13531353 // This value may be smaller or larger than the target's pointer type, and
13541354 // therefore require extension or truncating.
48644864 EVT ThisVT = MVT::Other;
48654865
48664866 const TargetRegisterClass *RC = *RCI;
4867 // If none of the the value types for this register class are valid, we
4867 // If none of the value types for this register class are valid, we
48684868 // can't use it. For example, 64-bit reg classes on 32-bit targets.
48694869 for (TargetRegisterClass::vt_iterator I = RC->vt_begin(), E = RC->vt_end();
48704870 I != E; ++I) {
23652365 E = RI->regclass_end(); RCI != E; ++RCI) {
23662366 const TargetRegisterClass *RC = *RCI;
23672367
2368 // If none of the the value types for this register class are valid, we
2368 // If none of the value types for this register class are valid, we
23692369 // can't use it. For example, 64-bit reg classes on 32-bit targets.
23702370 bool isLegal = false;
23712371 for (TargetRegisterClass::vt_iterator I = RC->vt_begin(), E = RC->vt_end();
196196
197197 SlotIndex FillerStart = ValLR->end, FillerEnd = BLR->start;
198198 // We are about to delete CopyMI, so need to remove it as the 'instruction
199 // that defines this value #'. Update the the valnum with the new defining
199 // that defines this value #'. Update the valnum with the new defining
200200 // instruction #.
201201 BValNo->def = FillerStart;
202202 BValNo->setCopy(0);
9494
9595 push_back(createEntry(0, index));
9696
97 // Iterate over the the function.
97 // Iterate over the function.
9898 for (MachineFunction::iterator mbbItr = mf->begin(), mbbEnd = mf->end();
9999 mbbItr != mbbEnd; ++mbbItr) {
100100 MachineBasicBlock *mbb = &*mbbItr;
4848 std::map > Stacks;
4949
5050 // Registers in UsedByAnother are PHI nodes that are themselves
51 // used as operands to another another PHI node
51 // used as operands to another PHI node
5252 std::set UsedByAnother;
5353
5454 // RenameSets are the is a map from a PHI-defined register
88 //
99 // This file implements the VirtRegMap class.
1010 //
11 // It also contains implementations of the the Spiller interface, which, given a
11 // It also contains implementations of the Spiller interface, which, given a
1212 // virtual register map and a machine function, eliminates all virtual
1313 // references by replacing them with physical register references - adding spill
1414 // code as necessary.
170170 ob->encoding.i = 0;
171171 ob->encoding.b.encoding = llvm::dwarf::DW_EH_PE_omit;
172172
173 // Put the info on both places, as libgcc uses the first or the the second
173 // Put the info on both places, as libgcc uses the first or the second
174174 // field. Note that we rely on having two pointers here. If fde_end was a
175175 // char, things would get complicated.
176176 ob->fde_end = (char*)LOI->unseenObjects;
272272 return clearUnusedBits();
273273 }
274274
275 /// Multiplies an integer array, x by a a uint64_t integer and places the result
275 /// Multiplies an integer array, x, by a uint64_t integer and places the result
276276 /// into dest.
277277 /// @returns the carry out of the multiplication.
278278 /// @brief Multiply a multi-digit APInt by a single digit (64-bit) integer.
17651765
17661766 // First, compose the values into an array of 32-bit words instead of
17671767 // 64-bit words. This is a necessity of both the "short division" algorithm
1768 // and the the Knuth "classical algorithm" which requires there to be native
1768 // and the Knuth "classical algorithm" which requires there to be native
17691769 // operations for +, -, and * on an m bit value with an m*2 bit result. We
17701770 // can't use 64-bit operands here because we don't have native results of
17711771 // 128-bits. Furthermore, casting the 64-bit values to 32-bit values won't
18401840 return GlobalDtors;
18411841 }
18421842
1843 // Otherwise, it it is other metadata, don't print it. This catches things
1843 // Otherwise, if it is other metadata, don't print it. This catches things
18441844 // like debug information.
18451845 if (GV->getSection() == "llvm.metadata")
18461846 return NotPrinted;
31123112 }
31133113
31143114 /// visitBuiltinCall - Handle the call to the specified builtin. Returns true
3115 /// if the entire call is handled, return false it it wasn't handled, and
3115 /// if the entire call is handled, return false if it wasn't handled, and
31163116 /// optionally set 'WroteCallee' if the callee has already been printed out.
31173117 bool CWriter::visitBuiltinCall(CallInst &I, Intrinsic::ID ID,
31183118 bool &WroteCallee) {
6767 TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
6868 }
6969
70 // We also need to encode the the information about the base type of
70 // We also need to encode the information about the base type of
7171 // pointer in TypeNo.
7272 DIType BaseType = DIDerivedType(Ty.getNode()).getTypeDerivedFrom();
7373 PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TagName);
117117 }
118118
119119 /// getHazardType - We return hazard for any non-branch instruction that would
120 /// terminate terminate the dispatch group. We turn NoopHazard for any
120 /// terminate the dispatch group. We turn NoopHazard for any
121121 /// instructions that wouldn't terminate the dispatch group that would cause a
122122 /// pipeline flush.
123123 ScheduleHazardRecognizer::HazardType PPCHazardRecognizer970::
198198 // Check to see if this function uses vector registers, which means we have to
199199 // save and restore the VRSAVE register and update it with the regs we use.
200200 //
201 // In this case, there will be virtual registers of vector type type created
201 // In this case, there will be virtual registers of vector type created
202202 // by the scheduler. Detect them now.
203203 bool HasVectorVReg = false;
204204 for (unsigned i = TargetRegisterInfo::FirstVirtualRegister,
6666 while (true) {
6767 // Find the next comma
6868 size_t Comma = S.find(',', Pos);
69 // If no comma found then the the rest of the string is used
69 // If no comma found then the rest of the string is used
7070 if (Comma == std::string::npos) {
7171 // Add string to vector
7272 V.push_back(S.substr(Pos));
375375 ... saving two instructions.
376376
377377 The basic idea is that a reload from a spill slot, can, if only one 4-byte
378 chunk is used, bring in 3 zeros the the one element instead of 4 elements.
378 chunk is used, bring in 3 zeros the one element instead of 4 elements.
379379 This can be used to simplify a variety of shuffle operations, where the
380380 elements are fixed zeros.
381381
21712171 if (IsCalleePop(isVarArg, CallConv))
21722172 NumBytesForCalleeToPush = NumBytes; // Callee pops everything
21732173 else if (!Is64Bit && CallConv != CallingConv::Fast && IsStructRet)
2174 // If this is is a call to a struct-return function, the callee
2174 // If this is a call to a struct-return function, the callee
21752175 // pops the hidden struct pointer, so we have to push it back.
21762176 // This is common for Darwin/X86, Linux & Mingw32 targets.
21772177 NumBytesForCalleeToPush = 4;
37033703 "movz{wl|x}\t{$src, $dst|$dst, $src}",
37043704 [(set GR32:$dst, (zextloadi32i16 addr:$src))]>, TB;
37053705
3706 // These are the same as the regular regular MOVZX32rr8 and MOVZX32rm8
3706 // These are the same as the regular MOVZX32rr8 and MOVZX32rm8
37073707 // except that they use GR32_NOREX for the output operand register class
37083708 // instead of GR32. This allows them to operate on h registers on x86-64.
37093709 def MOVZX32_NOREXrr8 : I<0xB6, MRMSrcReg,
685685 [(set R11, (pcrelwrapper tblockaddress:$addr))]>;
686686
687687 let isCall=1,
688 // All calls clobber the the link register and the non-callee-saved registers:
688 // All calls clobber the link register and the non-callee-saved registers:
689689 Defs = [R0, R1, R2, R3, R11, LR] in {
690690 def BL_u10 : _FU10<
691691 (outs),
778778 []>;
779779
780780 let isCall=1,
781 // All calls clobber the the link register and the non-callee-saved registers:
781 // All calls clobber the link register and the non-callee-saved registers:
782782 Defs = [R0, R1, R2, R3, R11, LR] in {
783783 def BLA_1r : _F1R<(outs), (ins GRRegs:$addr, variable_ops),
784784 "bla $addr",
246246 return Low != Set.end() && IsPrefix(*Low, Indices);
247247 }
248248
249 /// Mark the given indices (ToMark) as safe in the the given set of indices
249 /// Mark the given indices (ToMark) as safe in the given set of indices
250250 /// (Safe). Marking safe usually means adding ToMark to Safe. However, if there
251251 /// is already a prefix of Indices in Safe, Indices are implicitely marked safe
252252 /// already. Furthermore, any indices that Indices is itself a prefix of, are
116116 DominatorTree DT;
117117 DT.runOnFunction(*duplicateFunction);
118118
119 // Extract the body of the the if.
119 // Extract the body of the if.
120120 Function* extractedFunction = ExtractCodeRegion(DT, toExtract);
121121
122122 // Inline the top-level if test into all callers.
545545 std::swap(LHSCC, RHSCC);
546546 }
547547
548 // At this point, we know we have have two icmp instructions
548 // At this point, we know we have two icmp instructions
549549 // comparing a value against two constants and and'ing the result
550550 // together. Because of the above check, we know that we only have
551551 // icmp eq, icmp ne, icmp [su]lt, and icmp [SU]gt here. We also know
12251225 std::swap(LHSCC, RHSCC);
12261226 }
12271227
1228 // At this point, we know we have have two icmp instructions
1228 // At this point, we know we have two icmp instructions
12291229 // comparing a value against two constants and or'ing the result
12301230 // together. Because of the above check, we know that we only have
12311231 // ICMP_EQ, ICMP_NE, ICMP_LT, and ICMP_GT here. We also know (from the
379379 NeedCannIV = true;
380380 }
381381
382 // Now that we know the largest of of the induction variable expressions
382 // Now that we know the largest of the induction variable expressions
383383 // in this loop, insert a canonical induction variable of the largest size.
384384 Value *IndVar = 0;
385385 if (NeedCannIV) {
248248
249249 /// LinearizeExprTree - Given an associative binary expression tree, traverse
250250 /// all of the uses putting it into canonical form. This forces a left-linear
251 /// form of the the expression (((a+b)+c)+d), and collects information about the
251 /// form of the expression (((a+b)+c)+d), and collects information about the
252252 /// rank of the non-tree operands.
253253 ///
254254 /// NOTE: These intentionally destroys the expression tree operands (turning
298298 Success = false;
299299 MadeChange = true;
300300 } else if (RHSBO) {
301 // Turn (A+B)+(C+D) -> (((A+B)+C)+D). This guarantees the the RHS is not
301 // Turn (A+B)+(C+D) -> (((A+B)+C)+D). This guarantees the RHS is not
302302 // part of the expression tree.
303303 LinearizeExpr(I);
304304 LHS = LHSBO = cast(I->getOperand(0));
6767 Function *Callee = Call->getCalledFunction();
6868
6969 // Minimally sanity-check the CFG of half_powr to ensure that it contains
70 // the the kind of code we expect. If we're running this pass, we have
70 // the kind of code we expect. If we're running this pass, we have
7171 // reason to believe it will be what we expect.
7272 Function::iterator I = Callee->begin();
7373 BasicBlock *Prologue = I++;
1818 using namespace llvm;
1919
2020 /// CreateGlobalString - Make a new global variable with an initializer that
21 /// has array of i8 type filled in the the nul terminated string value
21 /// has array of i8 type filled in the nul terminated string value
2222 /// specified. If Name is specified, it is the name of the global variable
2323 /// created.
2424 Value *IRBuilderBase::CreateGlobalString(const char *Str, const Twine &Name) {