Start a JS backend cost model

Implement the TargetTransformInfo interface with JSTargetTransformInfo,
which gives costs used by the optimizer. The implementation is currently
fairly minimal.

Author: sunfishcode

lib/Target/JSBackend/CMakeLists.txt

@@ -3,6 +3,7 @@ add_llvm_target(JSBackendCodeGen
   ExpandI64.cpp
   JSBackend.cpp
   JSTargetMachine.cpp
+  JSTargetTransformInfo.cpp
   Relooper.cpp
   SimplifyAllocas.cpp
   )

lib/Target/JSBackend/JS.h

@@ -0,0 +1,29 @@
+//===-- JS.h - Top-level interface for JS representation ------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the entry points for global functions defined in the JS
+// target library, as used by the LLVM JIT.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TARGET_JS_H
+#define TARGET_JS_H
+
+namespace llvm {
+
+class ImmutablePass;
+class JSTargetMachine;
+
+/// createJSISelDag - This pass converts a legalized DAG into a
+/// \brief Creates an JS-specific Target Transformation Info pass.
+ImmutablePass *createJSTargetTransformInfoPass(const JSTargetMachine *TM);
+
+} // End llvm namespace
+
+#endif

lib/Target/JSBackend/JSTargetMachine.cpp

@@ -1,4 +1,18 @@
+//===-- JSTargetMachine.cpp - Define TargetMachine for the JS -------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the JS specific subclass of TargetMachine.
+//
+//===----------------------------------------------------------------------===//
+
 #include "JSTargetMachine.h"
+#include "llvm/CodeGen/Passes.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/PassManager.h"
 using namespace llvm;
@@ -12,3 +26,9 @@ JSTargetMachine::JSTargetMachine(const Target &T, StringRef Triple,
        "f32:32:32-f64:64:64-p:32:32:32-v128:32:128-n32-S128") {
   CodeGenInfo = T.createMCCodeGenInfo(Triple, RM, CM, OL);
 }
+
+void JSTargetMachine::addAnalysisPasses(PassManagerBase &PM) {
+  // We don't currently use BasicTTI because that depends on
+  // TargetLoweringInfo, which we don't currently implement.
+  PM.add(createJSTargetTransformInfoPass(this));
+}

lib/Target/JSBackend/JSTargetMachine.h

@@ -15,6 +15,7 @@
 #ifndef JSTARGETMACHINE_H
 #define JSTARGETMACHINE_H
 
+#include "JS.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/Target/TargetMachine.h"
 
@@ -39,6 +40,9 @@ class JSTargetMachine : public TargetMachine {
                                    AnalysisID StopAfter);
 
   virtual const DataLayout *getDataLayout() const { return &DL; }
+
+  /// \brief Register X86 analysis passes with a pass manager.
+  virtual void addAnalysisPasses(PassManagerBase &PM);
 };
 
 } // End llvm namespace

lib/Target/JSBackend/JSTargetTransformInfo.cpp

@@ -0,0 +1,103 @@
+//===-- JSTargetTransformInfo.cpp - JS specific TTI pass ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// This file implements a TargetTransformInfo analysis pass specific to the
+/// JS target machine. It uses the target's detailed information to provide
+/// more precise answers to certain TTI queries, while letting the target
+/// independent and default TTI implementations handle the rest.
+///
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "jstti"
+#include "JS.h"
+#include "JSTargetMachine.h"
+#include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Target/TargetLowering.h"
+#include "llvm/Target/CostTable.h"
+using namespace llvm;
+
+// Declare the pass initialization routine locally as target-specific passes
+// don't havve a target-wide initialization entry point, and so we rely on the
+// pass constructor initialization.
+namespace llvm {
+void initializeJSTTIPass(PassRegistry &);
+}
+
+namespace {
+
+class JSTTI : public ImmutablePass, public TargetTransformInfo {
+public:
+  JSTTI() : ImmutablePass(ID) {
+    llvm_unreachable("This pass cannot be directly constructed");
+  }
+
+  JSTTI(const JSTargetMachine *TM)
+      : ImmutablePass(ID) {
+    initializeJSTTIPass(*PassRegistry::getPassRegistry());
+  }
+
+  virtual void initializePass() {
+    pushTTIStack(this);
+  }
+
+  virtual void finalizePass() {
+    popTTIStack();
+  }
+
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    TargetTransformInfo::getAnalysisUsage(AU);
+  }
+
+  /// Pass identification.
+  static char ID;
+
+  /// Provide necessary pointer adjustments for the two base classes.
+  virtual void *getAdjustedAnalysisPointer(const void *ID) {
+    if (ID == &TargetTransformInfo::ID)
+      return (TargetTransformInfo*)this;
+    return this;
+  }
+
+  virtual PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) const;
+
+  virtual unsigned getRegisterBitWidth(bool Vector) const;
+};
+
+} // end anonymous namespace
+
+INITIALIZE_AG_PASS(JSTTI, TargetTransformInfo, "jstti",
+                   "JS Target Transform Info", true, true, false)
+char JSTTI::ID = 0;
+
+ImmutablePass *
+llvm::createJSTargetTransformInfoPass(const JSTargetMachine *TM) {
+  return new JSTTI(TM);
+}
+
+
+//===----------------------------------------------------------------------===//
+//
+// JS cost model.
+//
+//===----------------------------------------------------------------------===//
+
+JSTTI::PopcntSupportKind JSTTI::getPopcntSupport(unsigned TyWidth) const {
+  assert(isPowerOf2_32(TyWidth) && "Ty width must be power of 2");
+  // Hopefully we'll get popcnt in ES7, but for now, we just have software.
+  return PSK_Software;
+}
+
+unsigned JSTTI::getRegisterBitWidth(bool Vector) const {
+  if (Vector) {
+    return 128;
+  }
+
+  return 32;
+}