diff --git a/docs/AliasAnalysis.html b/docs/AliasAnalysis.html index 770cfe2190cc..e65279c1deb1 100644 --- a/docs/AliasAnalysis.html +++ b/docs/AliasAnalysis.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + LLVM Alias Analysis Infrastructure @@ -1060,7 +1061,7 @@ analysis directly.

Chris Lattner
LLVM Compiler Infrastructure
- Last modified: $Date: 2011-05-25 00:01:32 +0200 (Wed, 25 May 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/BranchWeightMetadata.html b/docs/BranchWeightMetadata.html index 6106e6ffac71..38b87baa3b70 100644 --- a/docs/BranchWeightMetadata.html +++ b/docs/BranchWeightMetadata.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + LLVM Branch Weight Metadata diff --git a/docs/Bugpoint.html b/docs/Bugpoint.html index bc78933fed6d..a1de242f6c7f 100644 --- a/docs/Bugpoint.html +++ b/docs/Bugpoint.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + LLVM bugpoint tool: design and usage @@ -231,7 +232,7 @@ non-obvious ways. Here are some hints and tips:

Chris Lattner
LLVM Compiler Infrastructure
- Last modified: $Date: 2011-08-30 20:26:11 +0200 (Tue, 30 Aug 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/CMake.html b/docs/CMake.html index 6389c7f22afd..feb1db05cbaa 100644 --- a/docs/CMake.html +++ b/docs/CMake.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + Building LLVM with CMake diff --git a/docs/CodeGenerator.html b/docs/CodeGenerator.html index e693a22369ec..9d0370fd3cc8 100644 --- a/docs/CodeGenerator.html +++ b/docs/CodeGenerator.html @@ -1813,6 +1813,8 @@ $ llc -regalloc=pbqp file.bc -o pbqp.s; Prolog/Epilog Code Insertion +

+

Compact Unwind @@ -1927,6 +1929,8 @@ $ llc -regalloc=pbqp file.bc -o pbqp.s;

+ +

Late Machine Code Optimizations @@ -2988,7 +2992,7 @@ MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory Chris Lattner
The LLVM Compiler Infrastructure
- Last modified: $Date: 2011-09-19 20:15:46 +0200 (Mon, 19 Sep 2011) $ + Last modified: $Date: 2011-11-03 07:43:54 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/CodingStandards.html b/docs/CodingStandards.html index 3153a6e10ccf..3ccbfc9c6235 100644 --- a/docs/CodingStandards.html +++ b/docs/CodingStandards.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + LLVM Coding Standards @@ -1526,7 +1527,7 @@ something.

Chris Lattner
LLVM Compiler Infrastructure
- Last modified: $Date: 2011-08-12 21:49:16 +0200 (Fri, 12 Aug 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/DebuggingJITedCode.html b/docs/DebuggingJITedCode.html index fa15633fddbf..a6883adc531f 100644 --- a/docs/DebuggingJITedCode.html +++ b/docs/DebuggingJITedCode.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + Debugging JITed Code With GDB @@ -146,7 +147,7 @@ coordinate with GDB to get better debug information. src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01"> Reid Kleckner
The LLVM Compiler Infrastructure
- Last modified: $Date: 2011-04-23 02:30:22 +0200 (Sat, 23 Apr 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/ExtendingLLVM.html b/docs/ExtendingLLVM.html index cf57fab1fd1a..15e698421066 100644 --- a/docs/ExtendingLLVM.html +++ b/docs/ExtendingLLVM.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + Extending LLVM: Adding instructions, intrinsics, types, etc. @@ -384,7 +385,7 @@ void calcTypeName(const Type *Ty, The LLVM Compiler Infrastructure
- Last modified: $Date: 2011-06-30 08:37:07 +0200 (Thu, 30 Jun 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/GetElementPtr.html b/docs/GetElementPtr.html index 4c347a6aaf12..f678e2723634 100644 --- a/docs/GetElementPtr.html +++ b/docs/GetElementPtr.html @@ -746,8 +746,8 @@ idx3 = (char*) &MyVar + 8 src="http://jigsaw.w3.org/css-validator/images/vcss-blue" alt="Valid CSS"> Valid HTML 4.01 - The LLVM Compiler Infrastructure
- Last modified: $Date: 2011-04-23 02:30:22 +0200 (Sat, 23 Apr 2011) $ + The LLVM Compiler Infrastructure
+ Last modified: $Date: 2011-11-03 07:43:54 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/GoldPlugin.html b/docs/GoldPlugin.html index 92ba4116a071..375dd3c8ca78 100644 --- a/docs/GoldPlugin.html +++ b/docs/GoldPlugin.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + LLVM gold plugin diff --git a/docs/HowToReleaseLLVM.html b/docs/HowToReleaseLLVM.html index c46ed5aa4a76..8588f3fa7c00 100644 --- a/docs/HowToReleaseLLVM.html +++ b/docs/HowToReleaseLLVM.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + How To Release LLVM To The Public @@ -574,7 +575,7 @@ $ svn copy https://llvm.org/svn/llvm-project/test-suite/branches/release_XY \ src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01"> The LLVM Compiler Infrastructure
- Last modified: $Date: 2011-10-17 22:32:14 +0200 (Mon, 17 Oct 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/HowToSubmitABug.html b/docs/HowToSubmitABug.html index 81d0f9960a3b..a6e5a70ac769 100644 --- a/docs/HowToSubmitABug.html +++ b/docs/HowToSubmitABug.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + How to submit an LLVM bug report @@ -340,7 +341,7 @@ the following:

Chris Lattner
The LLVM Compiler Infrastructure
- Last modified: $Date: 2011-06-07 22:03:13 +0200 (Tue, 07 Jun 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/LangRef.html b/docs/LangRef.html index 71e606d304cf..3d01b60a8b47 100644 --- a/docs/LangRef.html +++ b/docs/LangRef.html @@ -281,23 +281,6 @@
  • 'llvm.adjust.trampoline' Intrinsic
    • -
  • Atomic intrinsics -
      -
    1. llvm.memory_barrier
      2. -
    2. llvm.atomic.cmp.swap
      3. -
    3. llvm.atomic.swap
      4. -
    4. llvm.atomic.load.add
      5. -
    5. llvm.atomic.load.sub
      6. -
    6. llvm.atomic.load.and
      7. -
    7. llvm.atomic.load.nand
      8. -
    8. llvm.atomic.load.or
      9. -
    9. llvm.atomic.load.xor
      10. -
    10. llvm.atomic.load.max
      11. -
    11. llvm.atomic.load.min
      12. -
    12. llvm.atomic.load.umax
      13. -
    13. llvm.atomic.load.umin
      14. -
    -
  • Memory Use Markers
    1. llvm.lifetime.start
      2. @@ -1915,9 +1898,6 @@ in signal handlers).

      possible to have a two dimensional array, using an array as the element type of another array.

      - - -

      Aggregate Types @@ -2225,6 +2205,8 @@ in signal handlers).

      + +

      Constants

      @@ -6321,8 +6303,6 @@ declare void @llvm.va_end(i8*) - -

      Accurate Garbage Collection Intrinsics @@ -7018,8 +6998,6 @@ LLVM.

      - -

      'llvm.exp.*' Intrinsic @@ -7084,6 +7062,9 @@ LLVM.

      This function returns the same values as the libm log functions would, and handles error conditions in the same way.

      + + +

      'llvm.fma.*' Intrinsic

      @@ -7117,6 +7098,8 @@ LLVM.

      + +

      Bit Manipulation Intrinsics @@ -7810,503 +7793,6 @@ LLVM.

      - -

      - Atomic Operations and Synchronization Intrinsics -

      - -
      - -

      These intrinsic functions expand the "universal IR" of LLVM to represent - hardware constructs for atomic operations and memory synchronization. This - provides an interface to the hardware, not an interface to the programmer. It - is aimed at a low enough level to allow any programming models or APIs - (Application Programming Interfaces) which need atomic behaviors to map - cleanly onto it. It is also modeled primarily on hardware behavior. Just as - hardware provides a "universal IR" for source languages, it also provides a - starting point for developing a "universal" atomic operation and - synchronization IR.

      - -

      These do not form an API such as high-level threading libraries, - software transaction memory systems, atomic primitives, and intrinsic - functions as found in BSD, GNU libc, atomic_ops, APR, and other system and - application libraries. The hardware interface provided by LLVM should allow - a clean implementation of all of these APIs and parallel programming models. - No one model or paradigm should be selected above others unless the hardware - itself ubiquitously does so.

      - - -

      - 'llvm.memory.barrier' Intrinsic -

      - -
      -
      Syntax:
      -
      -  declare void @llvm.memory.barrier(i1 <ll>, i1 <ls>, i1 <sl>, i1 <ss>, i1 <device>)
-
      - -
      Overview:
      -

      The llvm.memory.barrier intrinsic guarantees ordering between - specific pairs of memory access types.

      - -
      Arguments:
      -

      The llvm.memory.barrier intrinsic requires five boolean arguments. - The first four arguments enables a specific barrier as listed below. The - fifth argument specifies that the barrier applies to io or device or uncached - memory.

      - -
        -
      • ll: load-load barrier
        • -
      • ls: load-store barrier
        • -
      • sl: store-load barrier
        • -
      • ss: store-store barrier
        • -
      • device: barrier applies to device and uncached memory also.
        • -
      - -
      Semantics:
      -

      This intrinsic causes the system to enforce some ordering constraints upon - the loads and stores of the program. This barrier does not - indicate when any events will occur, it only enforces - an order in which they occur. For any of the specified pairs of load - and store operations (f.ex. load-load, or store-load), all of the first - operations preceding the barrier will complete before any of the second - operations succeeding the barrier begin. Specifically the semantics for each - pairing is as follows:

      - -
        -
      • ll: All loads before the barrier must complete before any load - after the barrier begins.
        • -
      • ls: All loads before the barrier must complete before any - store after the barrier begins.
        • -
      • ss: All stores before the barrier must complete before any - store after the barrier begins.
        • -
      • sl: All stores before the barrier must complete before any - load after the barrier begins.
        • -
      - -

      These semantics are applied with a logical "and" behavior when more than one - is enabled in a single memory barrier intrinsic.

      - -

      Backends may implement stronger barriers than those requested when they do - not support as fine grained a barrier as requested. Some architectures do - not need all types of barriers and on such architectures, these become - noops.

      - -
      Example:
      -
      -%mallocP  = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
-%ptr      = bitcast i8* %mallocP to i32*
-            store i32 4, %ptr
-
-%result1  = load i32* %ptr      ; yields {i32}:result1 = 4
-            call void @llvm.memory.barrier(i1 false, i1 true, i1 false, i1 false, i1 true)
-                                ; guarantee the above finishes
-            store i32 8, %ptr   ; before this begins
-
      - -
      - - -

      - 'llvm.atomic.cmp.swap.*' Intrinsic -

      - -
      - -
      Syntax:
      -

      This is an overloaded intrinsic. You can use llvm.atomic.cmp.swap on - any integer bit width and for different address spaces. Not all targets - support all bit widths however.

      - -
      -  declare i8 @llvm.atomic.cmp.swap.i8.p0i8(i8* <ptr>, i8 <cmp>, i8 <val>)
-  declare i16 @llvm.atomic.cmp.swap.i16.p0i16(i16* <ptr>, i16 <cmp>, i16 <val>)
-  declare i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* <ptr>, i32 <cmp>, i32 <val>)
-  declare i64 @llvm.atomic.cmp.swap.i64.p0i64(i64* <ptr>, i64 <cmp>, i64 <val>)
-
      - -
      Overview:
      -

      This loads a value in memory and compares it to a given value. If they are - equal, it stores a new value into the memory.

      - -
      Arguments:
      -

      The llvm.atomic.cmp.swap intrinsic takes three arguments. The result - as well as both cmp and val must be integer values with the - same bit width. The ptr argument must be a pointer to a value of - this integer type. While any bit width integer may be used, targets may only - lower representations they support in hardware.

      - -
      Semantics:
      -

      This entire intrinsic must be executed atomically. It first loads the value - in memory pointed to by ptr and compares it with the - value cmp. If they are equal, val is stored into the - memory. The loaded value is yielded in all cases. This provides the - equivalent of an atomic compare-and-swap operation within the SSA - framework.

      - -
      Examples:
      -
      -%mallocP  = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
-%ptr      = bitcast i8* %mallocP to i32*
-            store i32 4, %ptr
-
-%val1     = add i32 4, 4
-%result1  = call i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* %ptr, i32 4, %val1)
-                                          ; yields {i32}:result1 = 4
-%stored1  = icmp eq i32 %result1, 4       ; yields {i1}:stored1 = true
-%memval1  = load i32* %ptr                ; yields {i32}:memval1 = 8
-
-%val2     = add i32 1, 1
-%result2  = call i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* %ptr, i32 5, %val2)
-                                          ; yields {i32}:result2 = 8
-%stored2  = icmp eq i32 %result2, 5       ; yields {i1}:stored2 = false
-
-%memval2  = load i32* %ptr                ; yields {i32}:memval2 = 8
-
      - -
      - - -

      - 'llvm.atomic.swap.*' Intrinsic -

      - -
      -
      Syntax:
      - -

      This is an overloaded intrinsic. You can use llvm.atomic.swap on any - integer bit width. Not all targets support all bit widths however.

      - -
      -  declare i8 @llvm.atomic.swap.i8.p0i8(i8* <ptr>, i8 <val>)
-  declare i16 @llvm.atomic.swap.i16.p0i16(i16* <ptr>, i16 <val>)
-  declare i32 @llvm.atomic.swap.i32.p0i32(i32* <ptr>, i32 <val>)
-  declare i64 @llvm.atomic.swap.i64.p0i64(i64* <ptr>, i64 <val>)
-
      - -
      Overview:
      -

      This intrinsic loads the value stored in memory at ptr and yields - the value from memory. It then stores the value in val in the memory - at ptr.

      - -
      Arguments:
      -

      The llvm.atomic.swap intrinsic takes two arguments. Both - the val argument and the result must be integers of the same bit - width. The first argument, ptr, must be a pointer to a value of this - integer type. The targets may only lower integer representations they - support.

      - -
      Semantics:
      -

      This intrinsic loads the value pointed to by ptr, yields it, and - stores val back into ptr atomically. This provides the - equivalent of an atomic swap operation within the SSA framework.

      - -
      Examples:
      -
      -%mallocP  = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
-%ptr      = bitcast i8* %mallocP to i32*
-            store i32 4, %ptr
-
-%val1     = add i32 4, 4
-%result1  = call i32 @llvm.atomic.swap.i32.p0i32(i32* %ptr, i32 %val1)
-                                        ; yields {i32}:result1 = 4
-%stored1  = icmp eq i32 %result1, 4     ; yields {i1}:stored1 = true
-%memval1  = load i32* %ptr              ; yields {i32}:memval1 = 8
-
-%val2     = add i32 1, 1
-%result2  = call i32 @llvm.atomic.swap.i32.p0i32(i32* %ptr, i32 %val2)
-                                        ; yields {i32}:result2 = 8
-
-%stored2  = icmp eq i32 %result2, 8     ; yields {i1}:stored2 = true
-%memval2  = load i32* %ptr              ; yields {i32}:memval2 = 2
-
      - -
      - - -

      - 'llvm.atomic.load.add.*' Intrinsic -

      - -
      - -
      Syntax:
      -

      This is an overloaded intrinsic. You can use llvm.atomic.load.add on - any integer bit width. Not all targets support all bit widths however.

      - -
      -  declare i8 @llvm.atomic.load.add.i8.p0i8(i8* <ptr>, i8 <delta>)
-  declare i16 @llvm.atomic.load.add.i16.p0i16(i16* <ptr>, i16 <delta>)
-  declare i32 @llvm.atomic.load.add.i32.p0i32(i32* <ptr>, i32 <delta>)
-  declare i64 @llvm.atomic.load.add.i64.p0i64(i64* <ptr>, i64 <delta>)
-
      - -
      Overview:
      -

      This intrinsic adds delta to the value stored in memory - at ptr. It yields the original value at ptr.

      - -
      Arguments:
      -

      The intrinsic takes two arguments, the first a pointer to an integer value - and the second an integer value. The result is also an integer value. These - integer types can have any bit width, but they must all have the same bit - width. The targets may only lower integer representations they support.

      - -
      Semantics:
      -

      This intrinsic does a series of operations atomically. It first loads the - value stored at ptr. It then adds delta, stores the result - to ptr. It yields the original value stored at ptr.

      - -
      Examples:
      -
      -%mallocP  = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
-%ptr      = bitcast i8* %mallocP to i32*
-            store i32 4, %ptr
-%result1  = call i32 @llvm.atomic.load.add.i32.p0i32(i32* %ptr, i32 4)
-                                ; yields {i32}:result1 = 4
-%result2  = call i32 @llvm.atomic.load.add.i32.p0i32(i32* %ptr, i32 2)
-                                ; yields {i32}:result2 = 8
-%result3  = call i32 @llvm.atomic.load.add.i32.p0i32(i32* %ptr, i32 5)
-                                ; yields {i32}:result3 = 10
-%memval1  = load i32* %ptr      ; yields {i32}:memval1 = 15
-
      - -
      - - -

      - 'llvm.atomic.load.sub.*' Intrinsic -

      - -
      - -
      Syntax:
      -

      This is an overloaded intrinsic. You can use llvm.atomic.load.sub on - any integer bit width and for different address spaces. Not all targets - support all bit widths however.

      - -
      -  declare i8 @llvm.atomic.load.sub.i8.p0i32(i8* <ptr>, i8 <delta>)
-  declare i16 @llvm.atomic.load.sub.i16.p0i32(i16* <ptr>, i16 <delta>)
-  declare i32 @llvm.atomic.load.sub.i32.p0i32(i32* <ptr>, i32 <delta>)
-  declare i64 @llvm.atomic.load.sub.i64.p0i32(i64* <ptr>, i64 <delta>)
-
      - -
      Overview:
      -

      This intrinsic subtracts delta to the value stored in memory at - ptr. It yields the original value at ptr.

      - -
      Arguments:
      -

      The intrinsic takes two arguments, the first a pointer to an integer value - and the second an integer value. The result is also an integer value. These - integer types can have any bit width, but they must all have the same bit - width. The targets may only lower integer representations they support.

      - -
      Semantics:
      -

      This intrinsic does a series of operations atomically. It first loads the - value stored at ptr. It then subtracts delta, stores the - result to ptr. It yields the original value stored - at ptr.

      - -
      Examples:
      -
      -%mallocP  = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
-%ptr      = bitcast i8* %mallocP to i32*
-            store i32 8, %ptr
-%result1  = call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %ptr, i32 4)
-                                ; yields {i32}:result1 = 8
-%result2  = call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %ptr, i32 2)
-                                ; yields {i32}:result2 = 4
-%result3  = call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %ptr, i32 5)
-                                ; yields {i32}:result3 = 2
-%memval1  = load i32* %ptr      ; yields {i32}:memval1 = -3
-
      - -
      - - -

      - - 'llvm.atomic.load.and.*' Intrinsic - -
      - - 'llvm.atomic.load.nand.*' Intrinsic - -
      - - 'llvm.atomic.load.or.*' Intrinsic - -
      - - 'llvm.atomic.load.xor.*' Intrinsic - -

      - -
      - -
      Syntax:
      -

      These are overloaded intrinsics. You can - use llvm.atomic.load_and, llvm.atomic.load_nand, - llvm.atomic.load_or, and llvm.atomic.load_xor on any integer - bit width and for different address spaces. Not all targets support all bit - widths however.

      - -
      -  declare i8 @llvm.atomic.load.and.i8.p0i8(i8* <ptr>, i8 <delta>)
-  declare i16 @llvm.atomic.load.and.i16.p0i16(i16* <ptr>, i16 <delta>)
-  declare i32 @llvm.atomic.load.and.i32.p0i32(i32* <ptr>, i32 <delta>)
-  declare i64 @llvm.atomic.load.and.i64.p0i64(i64* <ptr>, i64 <delta>)
-
      - -
      -  declare i8 @llvm.atomic.load.or.i8.p0i8(i8* <ptr>, i8 <delta>)
-  declare i16 @llvm.atomic.load.or.i16.p0i16(i16* <ptr>, i16 <delta>)
-  declare i32 @llvm.atomic.load.or.i32.p0i32(i32* <ptr>, i32 <delta>)
-  declare i64 @llvm.atomic.load.or.i64.p0i64(i64* <ptr>, i64 <delta>)
-
      - -
      -  declare i8 @llvm.atomic.load.nand.i8.p0i32(i8* <ptr>, i8 <delta>)
-  declare i16 @llvm.atomic.load.nand.i16.p0i32(i16* <ptr>, i16 <delta>)
-  declare i32 @llvm.atomic.load.nand.i32.p0i32(i32* <ptr>, i32 <delta>)
-  declare i64 @llvm.atomic.load.nand.i64.p0i32(i64* <ptr>, i64 <delta>)
-
      - -
      -  declare i8 @llvm.atomic.load.xor.i8.p0i32(i8* <ptr>, i8 <delta>)
-  declare i16 @llvm.atomic.load.xor.i16.p0i32(i16* <ptr>, i16 <delta>)
-  declare i32 @llvm.atomic.load.xor.i32.p0i32(i32* <ptr>, i32 <delta>)
-  declare i64 @llvm.atomic.load.xor.i64.p0i32(i64* <ptr>, i64 <delta>)
-
      - -
      Overview:
      -

      These intrinsics bitwise the operation (and, nand, or, xor) delta to - the value stored in memory at ptr. It yields the original value - at ptr.

      - -
      Arguments:
      -

      These intrinsics take two arguments, the first a pointer to an integer value - and the second an integer value. The result is also an integer value. These - integer types can have any bit width, but they must all have the same bit - width. The targets may only lower integer representations they support.

      - -
      Semantics:
      -

      These intrinsics does a series of operations atomically. They first load the - value stored at ptr. They then do the bitwise - operation delta, store the result to ptr. They yield the - original value stored at ptr.

      - -
      Examples:
      -
      -%mallocP  = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
-%ptr      = bitcast i8* %mallocP to i32*
-            store i32 0x0F0F, %ptr
-%result0  = call i32 @llvm.atomic.load.nand.i32.p0i32(i32* %ptr, i32 0xFF)
-                                ; yields {i32}:result0 = 0x0F0F
-%result1  = call i32 @llvm.atomic.load.and.i32.p0i32(i32* %ptr, i32 0xFF)
-                                ; yields {i32}:result1 = 0xFFFFFFF0
-%result2  = call i32 @llvm.atomic.load.or.i32.p0i32(i32* %ptr, i32 0F)
-                                ; yields {i32}:result2 = 0xF0
-%result3  = call i32 @llvm.atomic.load.xor.i32.p0i32(i32* %ptr, i32 0F)
-                                ; yields {i32}:result3 = FF
-%memval1  = load i32* %ptr      ; yields {i32}:memval1 = F0
-
      - -
      - - -

      - - 'llvm.atomic.load.max.*' Intrinsic - -
      - - 'llvm.atomic.load.min.*' Intrinsic - -
      - - 'llvm.atomic.load.umax.*' Intrinsic - -
      - - 'llvm.atomic.load.umin.*' Intrinsic - -

      - -
      - -
      Syntax:
      -

      These are overloaded intrinsics. You can use llvm.atomic.load_max, - llvm.atomic.load_min, llvm.atomic.load_umax, and - llvm.atomic.load_umin on any integer bit width and for different - address spaces. Not all targets support all bit widths however.

      - -
      -  declare i8 @llvm.atomic.load.max.i8.p0i8(i8* <ptr>, i8 <delta>)
-  declare i16 @llvm.atomic.load.max.i16.p0i16(i16* <ptr>, i16 <delta>)
-  declare i32 @llvm.atomic.load.max.i32.p0i32(i32* <ptr>, i32 <delta>)
-  declare i64 @llvm.atomic.load.max.i64.p0i64(i64* <ptr>, i64 <delta>)
-
      - -
      -  declare i8 @llvm.atomic.load.min.i8.p0i8(i8* <ptr>, i8 <delta>)
-  declare i16 @llvm.atomic.load.min.i16.p0i16(i16* <ptr>, i16 <delta>)
-  declare i32 @llvm.atomic.load.min.i32.p0i32(i32* <ptr>, i32 <delta>)
-  declare i64 @llvm.atomic.load.min.i64.p0i64(i64* <ptr>, i64 <delta>)
-
      - -
      -  declare i8 @llvm.atomic.load.umax.i8.p0i8(i8* <ptr>, i8 <delta>)
-  declare i16 @llvm.atomic.load.umax.i16.p0i16(i16* <ptr>, i16 <delta>)
-  declare i32 @llvm.atomic.load.umax.i32.p0i32(i32* <ptr>, i32 <delta>)
-  declare i64 @llvm.atomic.load.umax.i64.p0i64(i64* <ptr>, i64 <delta>)
-
      - -
      -  declare i8 @llvm.atomic.load.umin.i8.p0i8(i8* <ptr>, i8 <delta>)
-  declare i16 @llvm.atomic.load.umin.i16.p0i16(i16* <ptr>, i16 <delta>)
-  declare i32 @llvm.atomic.load.umin.i32.p0i32(i32* <ptr>, i32 <delta>)
-  declare i64 @llvm.atomic.load.umin.i64.p0i64(i64* <ptr>, i64 <delta>)
-
      - -
      Overview:
      -

      These intrinsics takes the signed or unsigned minimum or maximum of - delta and the value stored in memory at ptr. It yields the - original value at ptr.

      - -
      Arguments:
      -

      These intrinsics take two arguments, the first a pointer to an integer value - and the second an integer value. The result is also an integer value. These - integer types can have any bit width, but they must all have the same bit - width. The targets may only lower integer representations they support.

      - -
      Semantics:
      -

      These intrinsics does a series of operations atomically. They first load the - value stored at ptr. They then do the signed or unsigned min or - max delta and the value, store the result to ptr. They - yield the original value stored at ptr.

      - -
      Examples:
      -
      -%mallocP  = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
-%ptr      = bitcast i8* %mallocP to i32*
-            store i32 7, %ptr
-%result0  = call i32 @llvm.atomic.load.min.i32.p0i32(i32* %ptr, i32 -2)
-                                ; yields {i32}:result0 = 7
-%result1  = call i32 @llvm.atomic.load.max.i32.p0i32(i32* %ptr, i32 8)
-                                ; yields {i32}:result1 = -2
-%result2  = call i32 @llvm.atomic.load.umin.i32.p0i32(i32* %ptr, i32 10)
-                                ; yields {i32}:result2 = 8
-%result3  = call i32 @llvm.atomic.load.umax.i32.p0i32(i32* %ptr, i32 30)
-                                ; yields {i32}:result3 = 8
-%memval1  = load i32* %ptr      ; yields {i32}:memval1 = 30
-
      - -
      - -
      -

      Memory Use Markers @@ -8615,7 +8101,7 @@ LLVM.

      Chris Lattner
      The LLVM Compiler Infrastructure
      - Last modified: $Date: 2011-10-14 01:04:49 +0200 (Fri, 14 Oct 2011) $ + Last modified: $Date: 2011-11-03 07:43:54 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/LinkTimeOptimization.html b/docs/LinkTimeOptimization.html index a1e8bba74d05..63403ca5f636 100644 --- a/docs/LinkTimeOptimization.html +++ b/docs/LinkTimeOptimization.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + LLVM Link Time Optimization: Design and Implementation @@ -392,7 +393,7 @@ of the native object files.

      Devang Patel and Nick Kledzik
      LLVM Compiler Infrastructure
      - Last modified: $Date: 2011-09-18 14:51:05 +0200 (Sun, 18 Sep 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/Packaging.html b/docs/Packaging.html index b9329726991f..e3cdf7911aec 100644 --- a/docs/Packaging.html +++ b/docs/Packaging.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + Advice on Packaging LLVM @@ -112,7 +113,7 @@ line numbers. Valid HTML 4.01 The LLVM Compiler Infrastructure
      - Last modified: $Date: 2011-04-23 02:30:22 +0200 (Sat, 23 Apr 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/Passes.html b/docs/Passes.html index eb4a11549e15..96d1aeefd4d3 100644 --- a/docs/Passes.html +++ b/docs/Passes.html @@ -226,11 +226,8 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "

      \n" if ! -basicaa: Basic Alias Analysis (stateless AA impl)

      -

      - This is the default implementation of the Alias Analysis interface - that simply implements a few identities (two different globals cannot alias, - etc), but otherwise does no analysis. -

      +

      A basic alias analysis pass that implements identities (two different + globals cannot alias, etc), but does no stateful analysis.

      @@ -527,9 +524,10 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "

      \n" if !

    • - Always returns "I don't know" for alias queries. NoAA is unlike other alias - analysis implementations, in that it does not chain to a previous analysis. As - such it doesn't follow many of the rules that other alias analyses must. + This is the default implementation of the Alias Analysis interface. It always + returns "I don't know" for alias queries. NoAA is unlike other alias analysis + implementations, in that it does not chain to a previous analysis. As such it + doesn't follow many of the rules that other alias analyses must.

    @@ -2041,7 +2039,7 @@ if (X < 3) { Reid Spencer
    LLVM Compiler Infrastructure
    - Last modified: $Date: 2011-08-04 00:18:20 +0200 (Thu, 04 Aug 2011) $ + Last modified: $Date: 2011-11-04 07:30:50 +0100 (Fri, 04 Nov 2011) $ diff --git a/docs/ProgrammersManual.html b/docs/ProgrammersManual.html index 3697dd7501ba..47fc6e99b276 100644 --- a/docs/ProgrammersManual.html +++ b/docs/ProgrammersManual.html @@ -879,9 +879,6 @@ elements (but could contain many), for example, it's much better to use . Doing so avoids (relatively) expensive malloc/free calls, which dwarf the cost of adding the elements to the container.

    - - -

    Sequential Containers (std::vector, std::list, etc) @@ -4055,7 +4052,7 @@ arguments. An argument has a pointer to the parent Function.

    Dinakar Dhurjati and Chris Lattner
    The LLVM Compiler Infrastructure
    - Last modified: $Date: 2011-10-11 08:33:56 +0200 (Tue, 11 Oct 2011) $ + Last modified: $Date: 2011-11-03 07:43:54 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/Projects.html b/docs/Projects.html index 068acde087e5..a3d68911d934 100644 --- a/docs/Projects.html +++ b/docs/Projects.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + Creating an LLVM Project @@ -481,7 +482,7 @@ Mailing List.

    John Criswell
    The LLVM Compiler Infrastructure
    - Last modified: $Date: 2011-06-03 04:20:48 +0200 (Fri, 03 Jun 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/ReleaseNotes.html b/docs/ReleaseNotes.html index b0d4f67e9836..56d0eb914839 100644 --- a/docs/ReleaseNotes.html +++ b/docs/ReleaseNotes.html @@ -189,13 +189,7 @@ Release Notes.

    -

    LLDB is a brand new member of the LLVM - umbrella of projects. LLDB is a next generation, high-performance - debugger. It is built as a set of reusable components which highly leverage - existing libraries in the larger LLVM Project, such as the Clang expression - parser, the LLVM disassembler and the LLVM JIT.

    - -

    LLDB is has advanced by leaps and bounds in the 3.0 timeframe. It is +

    LLDB has advanced by leaps and bounds in the 3.0 timeframe. It is dramatically more stable and useful, and includes both a new tutorial and a side-by-side comparison with @@ -210,13 +204,6 @@ Release Notes.

    -

    libc++ is another new member of the - LLVM family. It is an implementation of the C++ standard library, written - from the ground up to specifically target the forthcoming C++'0X standard and - focus on delivering great performance.

    - -

    In the LLVM 3.0 timeframe,

    -

    Like compiler_rt, libc++ is now dual licensed under the MIT and UIUC license, allowing it to be used more permissively.

    @@ -290,23 +277,257 @@ be used to verify some algorithms. projects that have already been updated to work with LLVM 3.0.

    -

    Crack Programming Language

    +

    AddressSanitizer

    + +
    + +

    AddressSanitizer + uses compiler instrumentation and a specialized malloc library to find C/C++ + bugs such as use-after-free and out-of-bound accesses to heap, stack, and + globals. The key feature of the tool is speed: the average slowdown + introduced by AddressSanitizer is less than 2x.

    + +
    + + +

    ClamAV

    + +
    + +

    Clam AntiVirus is an open source (GPL) + anti-virus toolkit for UNIX, designed especially for e-mail scanning on mail + gateways.

    + +

    Since version 0.96 it + has bytecode + signatures that allow writing detections for complex malware.

    + +

    It uses LLVM's JIT to speed up the execution of bytecode on X86, X86-64, + PPC32/64, falling back to its own interpreter otherwise. The git version was + updated to work with LLVM 3.0.

    + +
    + + +

    clReflect

    -

    Crack aims to provide - the ease of development of a scripting language with the performance of a - compiled language. The language derives concepts from C++, Java and Python, - incorporating object-oriented programming, operator overloading and strong - typing.

    +

    clReflect is a C++ + parser that uses clang/LLVM to derive a light-weight reflection database + suitable for use in game development. It comes with a very simple runtime + library for loading and querying the database, requiring no external + dependencies (including CRT), and an additional utility library for object + management and serialisation.

    + + +

    Cling C++ Interpreter

    + +
    + +

    Cling is an interactive compiler interface + (aka C++ interpreter). It uses LLVM's JIT and clang; it currently supports + C++ and C. It has a prompt interface, runs source files, calls into shared + libraries, prints the value of expressions, even does runtime lookup of + identifiers (dynamic scopes). And it just behaves like one would expect from + an interpreter.

    + +
    + + + -

    TTA-based Codesign Environment (TCE)

    +

    Glasgow Haskell Compiler (GHC)

    +

    GHC is an open source, state-of-the-art programming suite for Haskell, a + standard lazy functional programming language. It includes an optimizing + static compiler generating good code for a variety of platforms, together + with an interactive system for convenient, quick development.

    + +

    GHC 7.0 and onwards include an LLVM code generator, supporting LLVM 2.8 and + later. Since LLVM 2.9, GHC now includes experimental support for the ARM + platform with LLVM 3.0.

    + +
    + + +

    gwXscript

    + +
    + +

    gwXscript is an object oriented, + aspect oriented programming language which can create both executables (ELF, + EXE) and shared libraries (DLL, SO, DYNLIB). The compiler is implemented in + its own language and translates scripts into LLVM-IR which can be optimized + and translated into native code by the LLVM framework. Source code in + gwScript contains definitions that expand the namespaces. So you can build + your project and simply 'plug out' features by removing a file. The remaining + project does not leave scars since you directly separate concerns by the + 'template' feature of gwX. It is also possible to add new features to a + project by just adding files and without editing the original project. This + language is used for example to create games or content management systems + that should be extendable.

    + +

    gwXscript is strongly typed and offers comfort with its native types string, + hash and array. You can easily write new libraries in gwXscript or native + code. gwXscript is type safe and users should not be able to crash your + program or execute malicious code except code that is eating CPU time.

    + +
    + + +

    include-what-you-use

    + +
    + +

    include-what-you-use + is a tool to ensure that a file directly #includes + all .h files that provide a symbol that the file uses. It also + removes superfluous #includes from source files.

    + +
    + + +

    LanguageKit and Pragmatic Smalltalk

    + +
    + +

    LanguageKit is + a framework for implementing dynamic languages sharing an object model with + Objective-C. It provides static and JIT compilation using LLVM along with + its own interpreter. Pragmatic Smalltalk is a dialect of Smalltalk, built on + top of LanguageKit, that interfaces directly with Objective-C, sharing the + same object representation and message sending behaviour. These projects are + developed as part of the Étoié desktop environment.

    + +
    + + +

    LuaAV

    + +
    + +

    LuaAV is a real-time + audiovisual scripting environment based around the Lua language and a + collection of libraries for sound, graphics, and other media protocols. LuaAV + uses LLVM and Clang to JIT compile efficient user-defined audio synthesis + routines specified in a declarative syntax.

    + +
    + + +

    Mono

    + +
    + +

    An open source, cross-platform implementation of C# and the CLR that is + binary compatible with Microsoft.NET. Has an optional, dynamically-loaded + LLVM code generation backend in Mini, the JIT compiler.

    + +

    Note that we use a Git mirror of LLVM with some patches. See: + https://github.com/mono/llvm

    + +
    + + +

    Portable OpenCL (pocl)

    + +
    + +

    Portable OpenCL is an open source implementation of the OpenCL standard which + can be easily adapted for new targets. One of the goals of the project is + improving performance portability of OpenCL programs, avoiding the need for + target-dependent manual optimizations. A "native" target is included, which + allows running OpenCL kernels on the host (CPU).

    + +
    + + +

    Pure

    + +
    +

    Pure is an + algebraic/functional programming language based on term rewriting. Programs + are collections of equations which are used to evaluate expressions in a + symbolic fashion. The interpreter uses LLVM as a backend to JIT-compile Pure + programs to fast native code. Pure offers dynamic typing, eager and lazy + evaluation, lexical closures, a hygienic macro system (also based on term + rewriting), built-in list and matrix support (including list and matrix + comprehensions) and an easy-to-use interface to C and other programming + languages (including the ability to load LLVM bitcode modules, and inline C, + C++, Fortran and Faust code in Pure programs if the corresponding LLVM-enabled + compilers are installed).

    + +

    Pure version 0.48 has been tested and is known to work with LLVM 3.0 + (and continues to work with older LLVM releases >= 2.5).

    + +
    + + +

    Renderscript

    + +
    + +

    Renderscript + is Android's advanced 3D graphics rendering and compute API. It provides a + portable C99-based language with extensions to facilitate common use cases + for enhancing graphics and thread level parallelism. The Renderscript + compiler frontend is based on Clang/LLVM. It emits a portable bitcode format + for the actual compiled script code, as well as reflects a Java interface for + developers to control the execution of the compiled bitcode. Executable + machine code is then generated from this bitcode by an LLVM backend on the + device. Renderscript is thus able to provide a mechanism by which Android + developers can improve performance of their applications while retaining + portability.

    + +
    + + +

    SAFECode

    + +
    + +

    SAFECode is a memory safe C/C++ + compiler built using LLVM. It takes standard, unannotated C/C++ code, + analyzes the code to ensure that memory accesses and array indexing + operations are safe, and instruments the code with run-time checks when + safety cannot be proven statically. SAFECode can be used as a debugging aid + (like Valgrind) to find and repair memory safety bugs. It can also be used + to protect code from security attacks at run-time.

    + +
    + + +

    The Stupid D Compiler (SDC)

    + +
    + +

    The Stupid D Compiler is a + project seeking to write a self-hosting compiler for the D programming + language without using the frontend of the reference compiler (DMD).

    + +
    + + +

    TTA-based Co-design Environment (TCE)

    + +
    +

    TCE is a toolset for designing application-specific processors (ASP) based on the Transport triggered architecture (TTA). The toolset provides a complete co-design flow from C/C++ programs down to synthesizable VHDL and parallel @@ -322,120 +543,140 @@ be used to verify some algorithms.

    +

    Tart Programming Language

    + +
    + +

    Tart is a general-purpose, + strongly typed programming language designed for application + developers. Strongly inspired by Python and C#, Tart focuses on practical + solutions for the professional software developer, while avoiding the clutter + and boilerplate of legacy languages like Java and C++. Although Tart is still + in development, the current implementation supports many features expected of + a modern programming language, such as garbage collection, powerful + bidirectional type inference, a greatly simplified syntax for template + metaprogramming, closures and function literals, reflection, operator + overloading, explicit mutability and immutability, and much more. Tart is + flexible enough to accommodate a broad range of programming styles and + philosophies, while maintaining a strong commitment to simplicity, minimalism + and elegance in design.

    + +
    + + +

    ThreadSanitizer

    + +
    + +

    ThreadSanitizer is a + data race detector for (mostly) C and C++ code, available for Linux, Mac OS + and Windows. On different systems, we use binary instrumentation frameworks + (Valgrind and Pin) as frontends that generate the program events for the race + detection algorithm. On Linux, there's an option of using LLVM-based + compile-time instrumentation.

    + +
    + + +

    The ZooLib C++ Cross-Platform Application Framework

    + +
    + +

    ZooLib is Open Source under the MIT + License. It provides GUI, filesystem access, TCP networking, thread-safe + memory management, threading and locking for Mac OS X, Classic Mac OS, + Microsoft Windows, POSIX operating systems with X11, BeOS, Haiku, Apple's iOS + and Research in Motion's BlackBerry.

    + +

    My current work is to use CLang's static analyzer to improve ZooLib's code + quality. I also plan to set up LLVM compiles of the demo programs and test + programs using CLang and LLVM on all the platforms that CLang, LLVM and + ZooLib all support.

    + +
    + + + -

    Pure

    - -
    - -

    Pure is an - algebraic/functional programming language based on term rewriting. Programs - are collections of equations which are used to evaluate expressions in a - symbolic fashion. The interpreter uses LLVM as a backend to JIT-compile Pure - programs to fast native code. Pure offers dynamic typing, eager and lazy - evaluation, lexical closures, a hygienic macro system (also based on term - rewriting), built-in list and matrix support (including list and matrix - comprehensions) and an easy-to-use interface to C and other programming - languages (including the ability to load LLVM bitcode modules, and inline C, - C++, Fortran and Faust code in Pure programs if the corresponding - LLVM-enabled compilers are installed).

    - -

    Pure version 0.47 has been tested and is known to work with LLVM 3.0 (and - continues to work with older LLVM releases >= 2.5).

    - +source, SystemC front-end. Unlike many +other front-ends, PinaVM actually executes the elaboration of the +program analyzed using LLVM's JIT infrastructure. It later enriches the +bitcode with SystemC-specific information.

    +--> + + -

    Glasgow Haskell Compiler (GHC)

    - -
    - -

    GHC is an open source, state-of-the-art programming suite for Haskell, a - standard lazy functional programming language. It includes an optimizing - static compiler generating good code for a variety of platforms, together - with an interactive system for convenient, quick development.

    - -

    In addition to the existing C and native code generators, GHC 7.0 now - supports an LLVM code generator. GHC supports LLVM 2.7 and later.

    - +

    OpenJDK 7 b112, IcedTea6 1.9 and IcedTea7 1.13 and later have been tested +and are known to work with LLVM 3.0 (and continue to work with older LLVM +releases >= 2.6 as well).

    +--> + + +
    @@ -698,6 +939,9 @@ Builder.CreateResume(UnwindData); Other Target Specific Improvements +

    PPC32/ELF va_arg was implemented.

    +

    PPC32 initial support for .o file writing was implemented.

    +

    Windows (32-bit)

    @@ -943,8 +1190,7 @@ Builder.CreateResume(UnwindData);
      -
    • The Linux PPC32/ABI support needs testing for the interpreter and static - compilation, and lacks support for debug information.
      • +
    • The PPC32/ELF support lacks PIC support.
    @@ -1096,7 +1342,7 @@ Builder.CreateResume(UnwindData); src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01"> LLVM Compiler Infrastructure
    - Last modified: $Date: 2011-10-17 08:31:58 +0200 (Mon, 17 Oct 2011) $ + Last modified: $Date: 2011-11-01 05:51:35 +0100 (Tue, 01 Nov 2011) $ diff --git a/docs/SystemLibrary.html b/docs/SystemLibrary.html index 57dc2391d535..24c4dc533182 100644 --- a/docs/SystemLibrary.html +++ b/docs/SystemLibrary.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + System Library @@ -309,7 +310,7 @@ Reid Spencer
    LLVM Compiler Infrastructure
    - Last modified: $Date: 2011-04-23 02:30:22 +0200 (Sat, 23 Apr 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/TableGenFundamentals.html b/docs/TableGenFundamentals.html index f607ef8ebeab..92b90e687bbf 100644 --- a/docs/TableGenFundamentals.html +++ b/docs/TableGenFundamentals.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + TableGen Fundamentals @@ -911,7 +912,7 @@ This should highlight the APIs in TableGen/Record.h.

    Chris Lattner
    LLVM Compiler Infrastructure
    - Last modified: $Date: 2011-10-07 20:25:05 +0200 (Fri, 07 Oct 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/TestingGuide.html b/docs/TestingGuide.html index 5a28c447f3a3..eb3714272d33 100644 --- a/docs/TestingGuide.html +++ b/docs/TestingGuide.html @@ -2,6 +2,7 @@ "http://www.w3.org/TR/html4/strict.dtd"> + LLVM Testing Infrastructure Guide @@ -1206,7 +1207,7 @@ example reports that can do fancy stuff.

    John T. Criswell, Daniel Dunbar, Reid Spencer, and Tanya Lattner
    The LLVM Compiler Infrastructure
    - Last modified: $Date: 2011-05-18 20:07:16 +0200 (Wed, 18 May 2011) $ + Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $ diff --git a/docs/UsingLibraries.html b/docs/UsingLibraries.html index 2c1c69a69a5f..6c1dd18aac92 100644 --- a/docs/UsingLibraries.html +++ b/docs/UsingLibraries.html @@ -1,7 +1,8 @@ - Using The LLVM Libraries + + Using The LLVM Libraries @@ -440,7 +441,7 @@ Reid Spencer The LLVM Compiler Infrastructure -
    Last modified: $Date: 2011-04-23 02:30:22 +0200 (Sat, 23 Apr 2011) $
    +
    Last modified: $Date: 2011-11-03 07:43:23 +0100 (Thu, 03 Nov 2011) $