Android splitstack implementation

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "projects/compiler-rt"]
+        path = projects/compiler-rt
+        url = git://github.com/brson/compiler-rt
+[submodule "tools/clang"]
+        path = tools/clang
+        url = git://github.com/brson/clang

Makefile.rules

@@ -86,6 +86,16 @@ ifndef TARGET_NATIVE_ARCH
 TARGET_NATIVE_ARCH := $(ARCH)
 endif
 
+PYTHONVERSION := $(shell expr `python -V 2>&1 | cut -f1 -d. | sed -e 's/Python //'`)
+
+ifeq "$(PYTHONVERSION)" "3"
+    PYTHON := python2
+endif
+
+ifndef PYTHON
+    PYTHON := python
+endif
+
 # The rule to create the LLVMBuild Makefile fragment as well as the llvm-config
 # library table.
 #
@@ -97,7 +107,7 @@ endif
 $(LLVMBuildMakeFrag): $(PROJ_SRC_ROOT)/Makefile.rules \
 		      $(PROJ_OBJ_ROOT)/Makefile.config
 	$(Echo) Constructing LLVMBuild project information.
-	$(Verb) $(LLVMBuildTool) \
+	$(Verb) $(PYTHON) $(LLVMBuildTool) \
 	  --native-target "$(TARGET_NATIVE_ARCH)" \
 	  --enable-targets "$(TARGETS_TO_BUILD)" \
 	  --enable-optional-components "$(OPTIONAL_COMPONENTS)" \

include/llvm/CodeGen/FastISel.h

@@ -24,6 +24,7 @@ class AllocaInst;
 class Constant;
 class ConstantFP;
 class FunctionLoweringInfo;
+class GCFunctionInfo;
 class Instruction;
 class LoadInst;
 class MachineBasicBlock;
@@ -59,6 +60,7 @@ class FastISel {
   const TargetLowering &TLI;
   const TargetRegisterInfo &TRI;
   const TargetLibraryInfo *LibInfo;
+  GCFunctionInfo &GFI;
 
   /// The position of the last instruction for materializing constants
   /// for use in the current block. It resets to EmitStartPt when it
@@ -147,7 +149,8 @@ class FastISel {
 
 protected:
   explicit FastISel(FunctionLoweringInfo &funcInfo,
-                    const TargetLibraryInfo *libInfo);
+                    const TargetLibraryInfo *libInfo,
+                    GCFunctionInfo &gcInfo);
 
   /// TargetSelectInstruction - This method is called by target-independent
   /// code when the normal FastISel process fails to select an instruction.

include/llvm/CodeGen/GCMetadata.h

@@ -34,15 +34,20 @@
 #define LLVM_CODEGEN_GCMETADATA_H
 
 #include "llvm/Pass.h"
+#include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/DebugLoc.h"
+#include <utility>
 
 namespace llvm {
+  class AllocaInst;
   class AsmPrinter;
   class GCStrategy;
   class Constant;
   class MCSymbol;
+  class TargetData;
+  class Value;
 
   namespace GC {
     /// PointKind - The type of a collector-safe point.
@@ -66,25 +71,82 @@ namespace llvm {
         : Kind(K), Label(L), Loc(DL) {}
   };
 
+  /// GCRootLoc - The location of an object managed by the garbage collector.
+  union GCRootLoc {
+    int StackOffset;    //< Offset from the stack pointer.
+    int PhysReg;        //< A physical register.
+  };
+
   /// GCRoot - Metadata for a pointer to an object managed by the garbage
   /// collector.
   struct GCRoot {
-    int Num;            ///< Usually a frame index.
-    int StackOffset;    ///< Offset from the stack pointer.
-    const Constant *Metadata; ///< Metadata straight from the call
-                              ///< to llvm.gcroot.
+    int Num;            //< Positive integers indicate a frame index; -1
+                        //  indicates a register.
+    GCRootLoc Loc;      //< The location of the object.
+    const Constant *Metadata;//< Metadata straight from the call to llvm.gcroot.
+
+    inline bool isStack() const { return Num >= 0; }
+    inline bool isReg() const { return !isStack(); }
+
+    GCRoot(int N, unsigned Offset, const Constant *MD)
+      : Num(N), Metadata(MD) {
+      Loc.StackOffset = Offset;
+    }
+  };
+
+  /// GCCalleeSavedInfo - Metadata for a callee-saved register.
+  struct GCCalleeSavedInfo {
+    unsigned Reg;     //< The physical register.
+    int Num;          //< The frame index.
+    int StackOffset;  //< Offset from the stack pointer.
 
-    GCRoot(int N, const Constant *MD) : Num(N), StackOffset(-1), Metadata(MD) {}
+    GCCalleeSavedInfo(unsigned R, int N, int SO)
+      : Reg(R), Num(N), StackOffset(SO) {}
   };
 
 
   /// GCFunctionInfo - Garbage collection metadata for a single function.
   ///
   class GCFunctionInfo {
   public:
+    class live_iterator {
+      GCFunctionInfo &GCFI;
+      unsigned PointIndex;
+      unsigned RootIndex;
+
+      inline void advance() {
+        for (++RootIndex; RootIndex < GCFI.roots_size(); ++RootIndex) {
+          if (GCFI.isLive(PointIndex, RootIndex))
+            break;
+        }
+      }
+
+    public:
+      live_iterator(GCFunctionInfo &FI, unsigned PI, unsigned RI)
+          : GCFI(FI), PointIndex(PI), RootIndex(RI) {
+        if (RootIndex < GCFI.roots_size() &&
+            !GCFI.isLive(PointIndex, RootIndex)) {
+          advance();
+        }
+      }
+
+      inline live_iterator& operator++() { advance(); return *this; }
+
+      inline const GCRoot &operator*() { return GCFI.getRoot(RootIndex); }
+      inline const GCRoot *operator->() { return &operator*(); }
+
+      inline bool operator==(const live_iterator &Other) {
+        return &GCFI == &Other.GCFI && PointIndex == Other.PointIndex &&
+               RootIndex == Other.RootIndex;
+      }
+      inline bool operator!=(const live_iterator &Other) {
+        return !operator==(Other);
+      }
+    };
+
     typedef std::vector<GCPoint>::iterator iterator;
     typedef std::vector<GCRoot>::iterator roots_iterator;
-    typedef std::vector<GCRoot>::const_iterator live_iterator;
+    typedef std::vector<GCCalleeSavedInfo>::iterator callee_saved_iterator;
 
   private:
     const Function &F;
@@ -93,15 +155,20 @@ namespace llvm {
     std::vector<GCRoot> Roots;
     std::vector<GCPoint> SafePoints;
 
-    // FIXME: Liveness. A 2D BitVector, perhaps?
-    //
-    //   BitVector Liveness;
-    //
-    //   bool islive(int point, int root) =
-    //     Liveness[point * SafePoints.size() + root]
-    //
     // The bit vector is the more compact representation where >3.2% of roots
     // are live per safe point (1.5% on 64-bit hosts).
+    BitVector Liveness;
+
+    // A bit vector that describes whether each root is global or local.
+    // Local roots have their liveness described by the Liveness bit vector,
+    // while global roots are live everywhere.
+    BitVector GlobalRoots;
+
+    // A mapping from safe point symbols to indices.
+    DenseMap<MCSymbol *, unsigned> SafePointSymbols;
+
+    // A list of callee-saved registers in this function.
+    std::vector<GCCalleeSavedInfo> CSInfo;
 
   public:
     GCFunctionInfo(const Function &F, GCStrategy &S);
@@ -115,25 +182,127 @@ namespace llvm {
     ///
     GCStrategy &getStrategy() { return S; }
 
-    /// addStackRoot - Registers a root that lives on the stack. Num is the
-    ///                stack object ID for the alloca (if the code generator is
-    //                 using  MachineFrameInfo).
-    void addStackRoot(int Num, const Constant *Metadata) {
-      Roots.push_back(GCRoot(Num, Metadata));
+    /// addGlobalRoot - Registers a root that lives on the stack and is live
+    /// everywhere. Num is the stack object ID for the alloca (if the code
+    /// generator is using MachineFrameInfo), while Offset is the offset in
+    /// bytes from that stack object.
+    void addGlobalRoot(int Num, unsigned Offset, const Constant *Metadata) {
+      assert(Liveness.size() == 0 && "Can't add roots after finalization!");
+      unsigned RootIndex = Roots.size();
+      Roots.push_back(GCRoot(Num, Offset, Metadata));
+
+      GlobalRoots.resize(Roots.size(), false);
+      GlobalRoots[RootIndex] = true;
+    }
+
+    /// addRegRoot - Registers a root that lives in a register and returns its
+    /// index. The actual physical register will be filled in after register
+    /// allocation.
+    unsigned addRegRoot(const Constant *Metadata) {
+      assert(Liveness.size() == 0 && "Can't add roots after finalization!");
+      unsigned RootIndex = Roots.size();
+      Roots.push_back(GCRoot(-1, 0, Metadata));
+      return RootIndex;
     }
 
     /// addSafePoint - Notes the existence of a safe point. Num is the ID of the
     /// label just prior to the safe point (if the code generator is using
     /// MachineModuleInfo).
     void addSafePoint(GC::PointKind Kind, MCSymbol *Label, DebugLoc DL) {
+      assert(Liveness.size() == 0 &&
+             "Can't add safe points after roots have been finalized!");
+      unsigned PointIndex = SafePoints.size();
       SafePoints.push_back(GCPoint(Kind, Label, DL));
+      SafePointSymbols[Label] = PointIndex;
+    }
+
+    /// getPoint - Returns the safe point with the given index.
+    GCPoint &getPoint(unsigned PointIndex) {
+      assert(PointIndex < SafePoints.size() &&
+             "No point with that index exists!");
+      return SafePoints[PointIndex];
+    }
+
+    /// getPointIndex - Returns the index of the safe point with the given
+    /// label.
+    unsigned getPointIndex(MCSymbol *Label) {
+      assert(SafePointSymbols.find(Label) != SafePointSymbols.end() &&
+             "No safe point with that symbol exists!");
+      return SafePointSymbols[Label];
+    }
+
+    /// getRoot - Returns the root with the given index.
+    inline GCRoot &getRoot(unsigned RootIndex) {
+      assert(RootIndex < Roots.size() && "Invalid root index!");
+      return Roots[RootIndex];
     }
 
+    /// finalizeRoots - Creates the liveness bit vector. After this call, no
+    /// more roots or safe points can be added.
+    void finalizeRoots() {
+      Liveness.resize(Roots.size() * SafePoints.size(), false);
+      GlobalRoots.resize(Roots.size(), false);
+    }
+
+    /// isRootGlobal - Returns true if the given root is a global root or false
+    /// otherwise.
+    bool isRootGlobal(unsigned RootIndex) const {
+      return GlobalRoots[RootIndex];
+    }
+
+    /// isLive - Returns true if the given root is live at the supplied safe
+    /// point or false otherwise.
+    bool isLive(unsigned PointIndex, unsigned RootIndex) const {
+      assert(Liveness.size() != 0 &&
+             "Liveness is not available until roots have been finalized!");
+      assert(RootIndex < Roots.size() && "Invalid root index!");
+      assert(PointIndex < SafePoints.size() && "Invalid safe point index!");
+      return GlobalRoots[RootIndex] ||
+        Liveness[PointIndex * Roots.size() + RootIndex];
+    }
+
+    /// setLive - Adjusts the liveness of the given root at the supplied safe
+    /// point.
+    void setLive(unsigned PointIndex, unsigned RootIndex, bool Live) {
+      assert(Liveness.size() != 0 &&
+             "Liveness is not available until roots have been finalized!");
+      assert(!GlobalRoots[RootIndex] &&
+             "Cannot adjust the liveness of a global root!");
+      assert(RootIndex < Roots.size() && "Invalid root index!");
+      assert(PointIndex < SafePoints.size() && "Invalid safe point index!");
+      Liveness[PointIndex * Roots.size() + RootIndex] = Live;
+    }
+
+    /// spillRegRoot - Moves the given register root to the stack and assigns
+    /// it the supplied frame index.
+    void spillRegRoot(unsigned RootIndex, int FrameIndex) {
+      assert(RootIndex < Roots.size() && "Invalid root index!");
+      assert(FrameIndex >= 0 && "Invalid frame index!");
+      Roots[RootIndex].Num = FrameIndex;
+    }
+
+    /// setRootLoc - Sets the final location of the given register root.
+    inline void setRootLoc(unsigned RootIndex, GCRootLoc Loc) {
+      assert(RootIndex < Roots.size() && "Invalid root index!");
+      Roots[RootIndex].Loc = Loc;
+    }
+
+    /// findGCRootOrigin - Traces the argument to llvm.gcroot back to its
+    /// origin (through any pointer casts or GEPs) and returns the original
+    /// value as well as the byte offset of the pointer of interest within it.
+    static std::pair<const AllocaInst *, unsigned>
+    findGCRootOrigin(const TargetData *TD, const Value *V);
+
     /// getFrameSize/setFrameSize - Records the function's frame size.
     ///
     uint64_t getFrameSize() const { return FrameSize; }
     void setFrameSize(uint64_t S) { FrameSize = S; }
 
+    /// addCalleeSavedReg - Records information about a callee-saved register.
+    void addCalleeSavedReg(unsigned Reg, int FI, int SO) {
+      CSInfo.push_back(GCCalleeSavedInfo(Reg, FI, SO));
+    }
+
     /// begin/end - Iterators for safe points.
     ///
     iterator begin() { return SafePoints.begin(); }
@@ -148,9 +317,26 @@ namespace llvm {
 
     /// live_begin/live_end - Iterators for live roots at a given safe point.
     ///
-    live_iterator live_begin(const iterator &p) { return roots_begin(); }
-    live_iterator live_end  (const iterator &p) { return roots_end();   }
-    size_t live_size(const iterator &p) const { return roots_size(); }
+    live_iterator live_begin(unsigned PointIndex) {
+      return live_iterator(*this, PointIndex, 0);
+    }
+    live_iterator live_end(unsigned PointIndex) {
+      return live_iterator(*this, PointIndex, roots_size());
+    }
+    size_t live_size(unsigned PointIndex) {
+      size_t Count = 0;
+      for (unsigned RI = 0; RI < Roots.size(); ++RI) {
+        if (isLive(PointIndex, RI))
+          ++Count;
+      }
+      return Count;
+    }
+
+    /// callee_saved_begin/callee_saved_end - Iterators for callee-saved
+    /// registers.
+    callee_saved_iterator callee_saved_begin() { return CSInfo.begin(); }
+    callee_saved_iterator callee_saved_end()   { return CSInfo.end(); }
+    size_t callee_saved_size() { return CSInfo.size(); }
   };
 
 

include/llvm/CodeGen/GCStrategy.h

@@ -70,9 +70,12 @@ namespace llvm {
     bool CustomWriteBarriers;  ///< Default is to insert stores.
     bool CustomRoots;          ///< Default is to pass through to backend.
     bool CustomSafePoints;     ///< Default is to use NeededSafePoints
-                               ///< to find safe points.
+                               ///  to find safe points.
     bool InitRoots;            ///< If set, roots are nulled during lowering.
     bool UsesMetadata;         ///< If set, backend must emit metadata tables.
+    bool UsesAutomaticRoots;   ///< If set, calls to llvm.gcroot are inserted
+                               ///  automatically for pointers in address space
+                               ///  1.
 
   public:
     GCStrategy();
@@ -128,6 +131,11 @@ namespace llvm {
     /// usesMetadata - If set, appropriate metadata tables must be emitted by
     ///                the back-end (assembler, JIT, or otherwise).
     bool usesMetadata() const { return UsesMetadata; }
+
+    /// usesAutomaticRoots - If set, calls to llvm.gcroot are automatically
+    ///                      inserted for structs that contain pointers in
+    ///                      address space 1.
+    bool usesAutomaticRoots() const { return UsesAutomaticRoots; }
 
     /// begin/end - Iterators for function metadata.
     /// 

include/llvm/CodeGen/GCs.h

@@ -30,6 +30,12 @@ namespace llvm {
   /// Creates a shadow stack garbage collector. This collector requires no code
   /// generator support.
   void linkShadowStackGC();
+
+  /// Creates a generic garbage collector.
+  void linkGenericGC();
+
+  /// Creates a generic metadata printer.
+  void linkGenericGCPrinter();
 }
 
 #endif