llvm.org GIT mirror llvm / c8e41c5
Fix a typo (the the => the) git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@160621 91177308-0d34-0410-b5e6-96231b3b80d8 Sylvestre Ledru 7 years ago
43 changed file(s) with 45 addition(s) and 45 deletion(s). Raw diff Collapse all Expand all
0 #
1 # This function determins if the the isinf function isavailable on this
1 # This function determins if the isinf function isavailable on this
22 # platform.
33 #
44 AC_DEFUN([AC_FUNC_ISINF],[
0 #
1 # This function determins if the the HUGE_VAL macro is compilable with the
1 # This function determins if the HUGE_VAL macro is compilable with the
22 # -pedantic switch or not. XCode < 2.4.1 doesn't get it right.
33 #
44 AC_DEFUN([AC_HUGE_VAL_CHECK],[
0 #
1 # This function determins if the the srand48,drand48,lrand48 functions are
1 # This function determins if the srand48,drand48,lrand48 functions are
22 # available on this platform.
33 #
44 AC_DEFUN([AC_FUNC_RAND48],[
317317 operation, and vice versa.
318318
319319 Notes for optimizers
320 In general, optimizers should treat this like a nothrow call; the the possible
320 In general, optimizers should treat this like a nothrow call; the possible
321321 optimizations are usually not interesting.
322322
323323 Notes for code generation
207207 When inserting or moving member files, this option specifies the destination of
208208 the new files as being before the *relpos* member. If *relpos* is not
209209 found, the files are placed at the end of the archive. This modifier is
210 identical to the the *i* modifier.
210 identical to the *i* modifier.
211211
212212
213213
121121
122122
  • Speed: The CommandLine library is very quick and uses little resources. The
  • 123123 parsing time of the library is directly proportional to the number of arguments
    124 parsed, not the the number of options recognized. Additionally, command line
    124 parsed, not the number of options recognized. Additionally, command line
    125125 argument values are captured transparently into user defined global variables,
    126126 which can be accessed like any other variable (and with the same
    127127 performance).
    626626 LLVM and to give you some basic information about the LLVM environment.

    627627
    628628

    The later sections of this guide describe the

    629 href="#layout">general layout of the the LLVM source tree, a
    629 href="#layout">general layout of the LLVM source tree, a
    630630 href="#tutorial">simple example using the LLVM tool chain, and
    631631 href="#links">links to find more information about LLVM or to get
    632632 help via e-mail.

    15341534 bitcode or assembly (with the -emit-llvm option) instead of the
    15351535 usual machine code output. It works just like any other GCC compiler,
    15361536 taking the typical -c, -S, -E, -o options that are typically used.
    1537 Additionally, the the source code for llvm-gcc is available as a
    1537 Additionally, the source code for llvm-gcc is available as a
    15381538 separate Subversion module.
    15391539
    15401540
    opt
    169169 C:\..> clang -c hello.c -emit-llvm -o hello.bc
    170170
    171171 This will create the result file ``hello.bc`` which is the LLVM bitcode
    172 that corresponds the the compiled program and the library facilities that
    172 that corresponds the compiled program and the library facilities that
    173173 it required. You can execute this file directly using ``lli`` tool,
    174174 compile it to native assembly with the ``llc``, optimize or analyze it
    175175 further with the ``opt`` tool, etc.
    14311431
  • If no match is found, and the type sought is an integer type, then the
  • 14321432 smallest integer type that is larger than the bitwidth of the sought type
    14331433 is used. If none of the specifications are larger than the bitwidth then
    1434 the the largest integer type is used. For example, given the default
    1434 the largest integer type is used. For example, given the default
    14351435 specifications above, the i7 type will use the alignment of i8 (next
    14361436 largest) while both i65 and i256 will use the alignment of i64 (largest
    14371437 specified).
    753753
    754754
    755755

    Provides other passes access to information on how the size and alignment

    756 required by the the target ABI for various data types.

    756 required by the target ABI for various data types.

    757757
    758758
    759759
    38633863 *Ty, LinkageTypes Linkage, const std::string &N = "", Module* Parent = 0)
    38643864
    38653865

    Constructor used when you need to create new Functions to add

    3866 the the program. The constructor must specify the type of the function to
    3866 the program. The constructor must specify the type of the function to
    38673867 create and what type of linkage the function should have. The
    38683868 href="#FunctionType">FunctionType argument
    38693869 specifies the formal arguments and return value for the function. The same
    4646
    4747
    4848
    49

    Welcome to the the final chapter of the "Implementing a

    49

    Welcome to the final chapter of the "Implementing a

    5050 language with LLVM" tutorial. In the course of this tutorial, we have grown
    5151 our little Kaleidoscope language from being a useless toy, to being a
    5252 semi-interesting (but probably still useless) toy. :)

    4646
    4747
    4848
    49

    Welcome to the the final chapter of the "Implementing a

    49

    Welcome to the final chapter of the "Implementing a

    5050 language with LLVM" tutorial. In the course of this tutorial, we have grown
    5151 our little Kaleidoscope language from being a useless toy, to being a
    5252 semi-interesting (but probably still useless) toy. :)

    186186 /// current node, counting both nodes.
    187187 unsigned getPathLength() const { return VisitStack.size(); }
    188188
    189 /// getPath - Return the n'th node in the path from the the entry node to the
    189 /// getPath - Return the n'th node in the path from the entry node to the
    190190 /// current node.
    191191 NodeType *getPath(unsigned n) const {
    192192 return VisitStack[n].first.getPointer();
    398398 }
    399399
    400400 /// getIndexBefore - Returns the index of the last indexed instruction
    401 /// before MI, or the the start index of its basic block.
    401 /// before MI, or the start index of its basic block.
    402402 /// MI is not required to have an index.
    403403 SlotIndex getIndexBefore(const MachineInstr *MI) const {
    404404 const MachineBasicBlock *MBB = MI->getParent();
    582582 /// @param file_offset Byte offset in file where mapping should begin.
    583583 /// @param size_t Byte length of range of the file to map.
    584584 /// @param map_writable If true, the file will be mapped in r/w such
    585 /// that changes to the the mapped buffer will be flushed back
    585 /// that changes to the mapped buffer will be flushed back
    586586 /// to the file. If false, the file will be mapped read-only
    587587 /// and the buffer will be read-only.
    588588 /// @param result Set to the start address of the mapped buffer.
    393393 /// has_error - Return the value of the flag in this raw_fd_ostream indicating
    394394 /// whether an output error has been encountered.
    395395 /// This doesn't implicitly flush any pending output. Also, it doesn't
    396 /// guarantee to detect all errors unless the the stream has been closed.
    396 /// guarantee to detect all errors unless the stream has been closed.
    397397 bool has_error() const {
    398398 return Error;
    399399 }
    11871187 ShouldFoldAtomicFences = fold;
    11881188 }
    11891189
    1190 /// setInsertFencesForAtomic - Set if the the DAG builder should
    1190 /// setInsertFencesForAtomic - Set if the DAG builder should
    11911191 /// automatically insert fences and reduce the order of atomic memory
    11921192 /// operations to Monotonic.
    11931193 void setInsertFencesForAtomic(bool fence) {
    3636 // We use this precondition to produce a cast that will dominate all its
    3737 // uses. In particular, this is crucial for the case where the builder's
    3838 // insertion point *is* the point where we were asked to put the cast.
    39 // Since we don't know the the builder's insertion point is actually
    39 // Since we don't know the builder's insertion point is actually
    4040 // where the uses will be added (only that it dominates it), we are
    4141 // not allowed to move it.
    4242 BasicBlock::iterator BIP = Builder.GetInsertPoint();
    211211 Scheduler->startBlock(MBB);
    212212
    213213 // Break the block into scheduling regions [I, RegionEnd), and schedule each
    214 // region as soon as it is discovered. RegionEnd points the the scheduling
    214 // region as soon as it is discovered. RegionEnd points the scheduling
    215215 // boundary at the bottom of the region. The DAG does not include RegionEnd,
    216216 // but the region does (i.e. the next RegionEnd is above the previous
    217217 // RegionBegin). If the current block has no terminator then RegionEnd ==
    852852 }
    853853
    854854 /// After backtracking, the hazard checker needs to be restored to a state
    855 /// corresponding the the current cycle.
    855 /// corresponding the current cycle.
    856856 void ScheduleDAGRRList::RestoreHazardCheckerBottomUp() {
    857857 HazardRec->Reset();
    858858
    5959 }
    6060
    6161 // Subclasses can implement this method to create specialized image instances.
    62 // The caller owns the the pointer that is returned.
    62 // The caller owns the pointer that is returned.
    6363 ObjectImage *RuntimeDyldImpl::createObjectImage(const MemoryBuffer *InputBuffer) {
    6464 ObjectFile *ObjFile = ObjectFile::createObjectFile(const_cast
    6565 (InputBuffer));
    402402
    403403 // See if we are aligning with nops, and if so do that first to try to fill
    404404 // the Count bytes. Then if that did not fill any bytes or there are any
    405 // bytes left to fill use the the Value and ValueSize to fill the rest.
    405 // bytes left to fill use the Value and ValueSize to fill the rest.
    406406 // If we are aligning with nops, ask that target to emit the right data.
    407407 if (AF.hasEmitNops()) {
    408408 if (!Asm.getBackend().writeNopData(Count, OW))
    197197 // Set the value of the symbol, as we are at the end of the section.
    198198 MCOS->EmitLabel(SectionEnd);
    199199
    200 // Switch back the the dwarf line section.
    200 // Switch back the dwarf line section.
    201201 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfLineSection());
    202202
    203203 const MCAsmInfo &asmInfo = MCOS->getContext().getAsmInfo();
    13961396 return false;
    13971397 }
    13981398
    1399 /// DiagHandler - will use the the last parsed cpp hash line filename comment
    1399 /// DiagHandler - will use the last parsed cpp hash line filename comment
    14001400 /// for the Filename and LineNo if any in the diagnostic.
    14011401 void AsmParser::DiagHandler(const SMDiagnostic &Diag, void *Context) {
    14021402 const AsmParser *Parser = static_cast(Context);
    21972197 //
    21982198 // On Cortex-A8, each pair of register loads / stores can be scheduled on the
    21992199 // same cycle. The scheduling for the first load / store must be done
    2200 // separately by assuming the the address is not 64-bit aligned.
    2200 // separately by assuming the address is not 64-bit aligned.
    22012201 //
    22022202 // On Cortex-A9, the formula is simply (#reg / 2) + (#reg % 2). If the address
    22032203 // is not 64-bit aligned, then AGU would take an extra cycle. For VFP / NEON
    602602 /// These can often be values in a literal pool near the Address of the
    603603 /// instruction. The Address of the instruction and its immediate Value are
    604604 /// used as a possible literal pool entry. The SymbolLookUp call back will
    605 /// return the name of a symbol referenced by the the literal pool's entry if
    605 /// return the name of a symbol referenced by the literal pool's entry if
    606606 /// the referenced address is that of a symbol. Or it will return a pointer to
    607607 /// a literal 'C' string if the referenced address of the literal pool's entry
    608608 /// is an address into a section with 'C' string literals.
    189189 // 0 - arm instructions
    190190 // 1 - thumb instructions
    191191 // the other half of the relocated expression is in the following pair
    192 // relocation entry in the the low 16 bits of r_address field.
    192 // relocation entry in the low 16 bits of r_address field.
    193193 unsigned ThumbBit = 0;
    194194 unsigned MovtBit = 0;
    195195 switch ((unsigned)Fixup.getKind()) {
    14841484 return false;
    14851485
    14861486 // The call to CreateRegs builds two sequential registers, to store the
    1487 // both the the returned values.
    1487 // both the returned values.
    14881488 unsigned ResultReg = FuncInfo.CreateRegs(I.getType());
    14891489 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(OpC), ResultReg)
    14901490 .addReg(Reg1).addReg(Reg2);
    16721672 SDValue Val;
    16731673
    16741674 // If this is a call to a function that returns an fp value on the floating
    1675 // point stack, we must guarantee the the value is popped from the stack, so
    1675 // point stack, we must guarantee the value is popped from the stack, so
    16761676 // a CopyFromReg is not good enough - the copy instruction may be eliminated
    16771677 // if the return value is not used. We use the FpPOP_RETVAL instruction
    16781678 // instead.
    379379 return isa(V) ? IC_CallOrUser : IC_User;
    380380 }
    381381
    382 /// IsRetain - Test if the the given class is objc_retain or
    382 /// IsRetain - Test if the given class is objc_retain or
    383383 /// equivalent.
    384384 static bool IsRetain(InstructionClass Class) {
    385385 return Class == IC_Retain ||
    386386 Class == IC_RetainRV;
    387387 }
    388388
    389 /// IsAutorelease - Test if the the given class is objc_autorelease or
    389 /// IsAutorelease - Test if the given class is objc_autorelease or
    390390 /// equivalent.
    391391 static bool IsAutorelease(InstructionClass Class) {
    392392 return Class == IC_Autorelease ||
    13291329 return false;
    13301330 }
    13311331
    1332 // If we folded the the first phi, PN dangles at this point. Refresh it. If
    1332 // If we folded the first phi, PN dangles at this point. Refresh it. If
    13331333 // we ran out of PHIs then we simplified them all.
    13341334 PN = dyn_cast(BB->begin());
    13351335 if (PN == 0) return true;
    0 #
    1 # This function determins if the the isinf function isavailable on this
    1 # This function determins if the isinf function isavailable on this
    22 # platform.
    33 #
    44 AC_DEFUN([AC_FUNC_ISINF],[
    0 #
    1 # This function determins if the the HUGE_VAL macro is compilable with the
    1 # This function determins if the HUGE_VAL macro is compilable with the
    22 # -pedantic switch or not. XCode < 2.4.1 doesn't get it right.
    33 #
    44 AC_DEFUN([AC_HUGE_VAL_CHECK],[
    0 #
    1 # This function determins if the the srand48,drand48,lrand48 functions are
    1 # This function determins if the srand48,drand48,lrand48 functions are
    22 # available on this platform.
    33 #
    44 AC_DEFUN([AC_FUNC_RAND48],[
    33 %0 = type opaque
    44 %struct.NSConstantString = type { i32*, i32, i8*, i32 }
    55
    6 ; Make sure that the string ends up the the correct section.
    6 ; Make sure that the string ends up the correct section.
    77
    88 ; CHECK: .section __TEXT,__cstring
    99 ; CHECK-NEXT: l_.str3:
    0 ; RUN: not llvm-as < %s 2>&1 | grep "value doesn't match function result type 'i32'"
    11
    2 ; Verify the the operand type of the ret instructions in a function match the
    2 ; Verify the operand type of the ret instructions in a function match the
    33 ; delcared return type of the function they live in.
    44 ;
    55
    155155 // If we're not running as a child, the first thing that we must do is
    156156 // determine what the problem is. Does the optimization series crash the
    157157 // compiler, or does it produce illegal code? We make the top-level
    158 // decision by trying to run all of the passes on the the input program,
    158 // decision by trying to run all of the passes on the input program,
    159159 // which should generate a bitcode file. If it does generate a bitcode
    160160 // file, then we know the compiler didn't crash, so try to diagnose a
    161161 // miscompilation.
    66 //
    77 //===----------------------------------------------------------------------===//
    88 //
    9 // This files implements the the LLVM difference Consumer
    9 // This files implements the LLVM difference Consumer
    1010 //
    1111 //===----------------------------------------------------------------------===//
    1212
    3434 raw_ostream &OS);
    3535
    3636
    37 /// Matcher - Base class for all the the DAG ISel Matcher representation
    37 /// Matcher - Base class for all the DAG ISel Matcher representation
    3838 /// nodes.
    3939 class Matcher {
    4040 // The next matcher node that is executed after this one. Null if this is the
    563563 }
    564564 }
    565565
    566 // Emit either the the value defined in the TableGen Record, or the default
    566 // Emit either the value defined in the TableGen Record, or the default
    567567 // value defined in the C++ header. The Record is null if the processor does not
    568568 // define a model.
    569569 void SubtargetEmitter::EmitProcessorProp(raw_ostream &OS, const Record *R,
    192192 done
    193193 }
    194194
    195 # Export sources to the the build directory.
    195 # Export sources to the build directory.
    196196 function export_sources() {
    197197 check_valid_urls
    198198
    14641464 return str;
    14651465 }
    14661466
    1467 // The following two functions only make sense if the the system
    1467 // The following two functions only make sense if the system
    14681468 // uses UTF-16 for wide string encoding. All supported systems
    14691469 // with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16.
    14701470