Add ScopeRegisterAnalysis

Summary:
Add a new Analysis - ```ScopeRegisterAnalysis```- which is used to map each bytecode to the register containing
the Environment that represents the original source-level scope where that instruction "lives".

Reviewed By: fbmal7

Differential Revision: D43394136

fbshipit-source-id: 4456e1ad13ad91809631d0ac822ea81c2673e4e1

Author: John Porto

include/hermes/BCGen/HBC/ISel.h

@@ -87,6 +87,11 @@ class HBCISel {
   /// and scope depth of each function.
   FunctionScopeAnalysis &scopeAnalysis_;
 
+  /// The scope register analysis, used to determine which register contains the
+  /// Environment that's equivalent to the source-level scope where this
+  /// instruction was emitted.
+  ScopeRegisterAnalysis &SRA_;
+
   /// For each Basic Block, we map to its beginning instruction location
   /// and the next basic block. We need this information to resolve jump
   /// targets and exception handler table.
@@ -185,11 +190,13 @@ class HBCISel {
       BytecodeFunctionGenerator *BCFGen,
       HVMRegisterAllocator &RA,
       FunctionScopeAnalysis &scopeAnalysis,
+      ScopeRegisterAnalysis &SRA,
       const BytecodeGenerationOptions &options)
       : F_(F),
         BCFGen_(BCFGen),
         RA_(RA),
         scopeAnalysis_(scopeAnalysis),
+        SRA_(SRA),
         bytecodeGenerationOptions_(options) {
     protoIdent_ = F->getContext().getIdentifier("__proto__");
   }

include/hermes/BCGen/RegAlloc.h

@@ -123,6 +123,7 @@ class RegisterFile {
 
 class Function;
 class Instruction;
+class ScopeCreationInst;
 class PhiInst;
 class CallInst;
 
@@ -344,6 +345,10 @@ class RegisterAllocator {
   /// \returns the computed live interval for the instruction \p I.
   Interval &getInstructionInterval(Instruction *I);
 
+  /// \return The register assigned to \p Value, if it is available at \p At; or
+  /// an invalid Register if \p Value is not available at \p At.
+  Register getRegisterForInstructionAt(Instruction *Value, Instruction *At);
+
   explicit RegisterAllocator(Function *func) : F(func) {}
 
   virtual ~RegisterAllocator() = default;
@@ -416,6 +421,59 @@ class RegisterAllocator {
   }
 };
 
+/// Analysis for mapping Instructions to the VM register holding its lexical
+/// Environment (or the closest one that's available). In the following example
+///
+///  1: CreateEnvironment r0
+///  2: LoadConstDouble r1, 1.0
+///  3: LoadConstDouble r2, 2.0
+///  4: AddN r0, r1, r2
+///  5: AddN r0, r0, r0
+///
+/// registerAndScopeForInstruction(1): invalid Register
+/// registerAndScopeForInstruction(2): r0
+/// registerAndScopeForInstruction(3): r0
+/// registerAndScopeForInstruction(4): r0
+/// registerAndScopeForInstruction(5): invalid Register
+///
+/// This analysis use the register allocation to provide that information, and
+/// thus register allocation must be done prior to using
+/// registerAndScopeForInstruction. However, the analysis should be created
+/// before register allocation is performed. That's necessary as the analysis
+/// pre-allocated the environment registers upon initialization in case the code
+/// is being compiled with debug information.
+class ScopeRegisterAnalysis {
+  ScopeRegisterAnalysis(const ScopeRegisterAnalysis &) = delete;
+  void operator=(const ScopeRegisterAnalysis &) = delete;
+
+ public:
+  /// Initializes this scope register analysis object. In full debug info
+  /// generation mode this constructor will also pre-allocate the environment
+  /// registers.
+  explicit ScopeRegisterAnalysis(Function *F, RegisterAllocator &RA);
+
+  /// \return a pair with the register and the ScopeDesc for the Environment
+  /// that's available at \p Inst. This Environment may be the one representing
+  /// the lexical scope for \p Inst or, if that's not available, one of its
+  /// parents; if no Environments are available at \p Inst, returns
+  /// std::pair(invalid register, nullptr ScopeDesc);
+  std::pair<Register, ScopeDesc *> registerAndScopeForInstruction(
+      Instruction *Inst);
+
+ private:
+  /// \return a pair with the register and the ScopeDesc for the Environment
+  /// created by \p SCI if it is available at \p Inst. If it's not available,
+  /// recursively try to find the closest Environment that's available at
+  /// \p Inst; if no Environments are available at \p Inst, returns
+  /// std::pair(invalid register, nullptr ScopeDesc);
+  std::pair<Register, ScopeDesc *> registerAndScopeAt(
+      Instruction *Inst,
+      ScopeCreationInst *SCI);
+
+  RegisterAllocator &RA_;
+  llvh::DenseMap<ScopeDesc *, ScopeCreationInst *> scopeCreationInsts_;
+};
+
 } // namespace hermes
 
 namespace llvh {

lib/BCGen/HBC/HBC.cpp

@@ -513,6 +513,7 @@ std::unique_ptr<BytecodeModule> hbc::generateBytecodeModule(
       funcGen = BytecodeFunctionGenerator::create(BMGen, 0);
     } else {
       HVMRegisterAllocator RA(&F);
+      ScopeRegisterAnalysis SRA(&F, RA);
       if (!options.optimizationEnabled) {
         RA.setFastPassThreshold(kFastRegisterAllocationThreshold);
         RA.setMemoryLimit(kRegisterAllocationMemoryLimit);
@@ -551,7 +552,7 @@ std::unique_ptr<BytecodeModule> hbc::generateBytecodeModule(
 
       funcGen =
           BytecodeFunctionGenerator::create(BMGen, RA.getMaxRegisterUsage());
-      HBCISel hbciSel(&F, funcGen.get(), RA, scopeAnalysis, options);
+      HBCISel hbciSel(&F, funcGen.get(), RA, scopeAnalysis, SRA, options);
       hbciSel.populateDebugCache(debugCache);
       hbciSel.generate(sourceMapGen);
       debugCache = hbciSel.getDebugCache();

lib/BCGen/RegAlloc.cpp

@@ -16,6 +16,7 @@
 #include "llvh/Support/Debug.h"
 #include "llvh/Support/raw_ostream.h"
 
+#include <algorithm>
 #include <queue>
 
 #define DEBUG_TYPE "regalloc"
@@ -380,6 +381,28 @@ Interval &RegisterAllocator::getInstructionInterval(Instruction *I) {
   return instructionInterval_[idx];
 }
 
+Register RegisterAllocator::getRegisterForInstructionAt(
+    Instruction *Value,
+    Instruction *At) {
+  if (hasInstructionNumber(Value) && hasInstructionNumber(At)) {
+    Register valueReg = getRegister(Value);
+    unsigned loc = getInstructionNumber(At);
+    if (valueReg.isValid()) {
+      // Check all of valueReg's intervals, and see if any of those contain loc.
+      const Interval &i = getInstructionInterval(Value);
+      auto itBegin = i.segments_.begin(), itEnd = i.segments_.end();
+      if (std::find_if(itBegin, itEnd, [loc](const Segment &s) {
+            return s.contains(loc);
+          })) {
+        return valueReg;
+      }
+    }
+  }
+
+  // Value is not available at At; return an invalid register.
+  return Register{};
+}
+
 bool RegisterAllocator::isManuallyAllocatedInterval(Instruction *I) {
   if (hasTargetSpecificLowering(I))
     return true;
@@ -926,4 +949,78 @@ bool llvh::DenseMapInfo<Register>::isEqual(Register LHS, Register RHS) {
   return LHS.getIndex() == RHS.getIndex();
 }
 
+namespace {
+static bool preallocateScopeRegisters(const Context &c) {
+  return c.getDebugInfoSetting() == DebugInfoSetting::ALL;
+}
+} // namespace
+
+ScopeRegisterAnalysis::ScopeRegisterAnalysis(Function *F, RegisterAllocator &RA)
+    : RA_(RA) {
+  // Initialize the ScopeDesc -> ScopeCreationInst map; if emitting full debug
+  // info, scopeCreationInsts will be used to reserve/pre-allocate the
+  // environment registers for scopes in F.
+  llvh::SmallVector<Value *, 4> scopeCreationInsts;
+  for (BasicBlock &BB : *F) {
+    for (Instruction &I : BB) {
+      if (llvh::isa<HBCResolveEnvironment>(I)) {
+        // HBCResolveEnvironment instructions are used to fetch an environment
+        // outside of F. The debugger doesn't need access to these "resolved"
+        // environment.
+        continue;
+      } else if (auto *SCI = llvh::dyn_cast<ScopeCreationInst>(&I)) {
+        assert(
+            SCI->getCreatedScopeDesc()->getFunction() == F &&
+            "ScopeCreationInst that is creating a scope of another function");
+        scopeCreationInsts_[SCI->getCreatedScopeDesc()] = SCI;
+        if (preallocateScopeRegisters(F->getContext())) {
+          LLVM_DEBUG(
+              llvh::dbgs() << "Reserving register for ScopeCreationInst in "
+                           << F->getOriginalOrInferredName() << "\n");
+          scopeCreationInsts.push_back(SCI);
+        }
+      }
+    }
+  }
+
+  if (!scopeCreationInsts.empty()) {
+    RA_.reserve(scopeCreationInsts);
+  }
+}
+
+std::pair<Register, ScopeDesc *> ScopeRegisterAnalysis::registerAndScopeAt(
+    Instruction *Value,
+    ScopeCreationInst *SCI) {
+  // If SCI's value is available in a register, ensure that the register is
+  // holding SCI's result at loc.
+  Register sciReg = RA_.getRegisterForInstructionAt(Value, SCI);
+  if (sciReg.isValid()) {
+    return std::make_pair(sciReg, SCI->getCreatedScopeDesc());
+  }
+
+  // sciReg is not alive at Value, so try to see if SCI's parent scope is.
+  auto parentIt =
+      scopeCreationInsts_.find(SCI->getCreatedScopeDesc()->getParent());
+  if (parentIt == scopeCreationInsts_.end()) {
+    // SCI's Parent scope is not available in any register.
+    return std::make_pair(Register{}, nullptr);
+  }
+
+  // Try again, this time on SCI's parent Environment.
+  return registerAndScopeAt(Value, parentIt->second);
+}
+
+std::pair<Register, ScopeDesc *>
+ScopeRegisterAnalysis::registerAndScopeForInstruction(Instruction *Inst) {
+  if (ScopeDesc *originalScope = Inst->getSourceLevelScope()) {
+    auto sciIt = scopeCreationInsts_.find(originalScope);
+    if (sciIt != scopeCreationInsts_.end()) {
+      ScopeCreationInst *originalScopeCreation = sciIt->second;
+      return registerAndScopeAt(Inst, originalScopeCreation);
+    }
+  }
+
+  return std::make_pair(Register{}, nullptr);
+}
+
 #undef DEBUG_TYPE

test/BCGen/HBC/debuggercheckbreak.js

@@ -11,12 +11,12 @@
 //CHECK-NEXT:Offset in debug table: source 0x0000, lexical 0x0000, textified callees 0x0000
 //CHECK-NEXT:    DeclareGlobalVar  "test1"
 //CHECK-NEXT:    CreateEnvironment r0
-//CHECK-NEXT:    CreateClosure     r1, r0, Function<test1>
-//CHECK-NEXT:    GetGlobalObject   r0
-//CHECK-NEXT:    PutById           r0, r1, 1, "test1"
-//CHECK-NEXT:    LoadConstUndefined r0
+//CHECK-NEXT:    CreateClosure     r2, r0, Function<test1>
+//CHECK-NEXT:    GetGlobalObject   r1
+//CHECK-NEXT:    PutById           r1, r2, 1, "test1"
+//CHECK-NEXT:    LoadConstUndefined r1
 //CHECK-NEXT:    AsyncBreakCheck
-//CHECK-NEXT:    Ret               r0
+//CHECK-NEXT:    Ret               r1
 
 //CHECK-LABEL:Function<test1>(1 params, 16 registers, 0 symbols):
 //CHECK-NEXT:Offset in debug table: {{.*}}

test/BCGen/HBC/scope-reg-analysis-captures.js

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// REQUIRES: slow_debug
+
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O0 %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=NOPC
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O0 -g %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=PC
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O0 -g0 %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=NOPC
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O0 -g1 %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=NOPC
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O0 -g2 %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=NOPC
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O0 -g3 %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=PC
+
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=NOPC
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O -g %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=PC
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O -g0 %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=NOPC
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O -g1 %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=NOPC
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O -g2 %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=NOPC
+// RUN: %hermesc -target=HBC -fno-inline -debug-only regalloc -dump-bytecode -O -g3 %s 2>&1 | %FileCheck --match-full-lines %s --check-prefix=PC
+
+function sink(n) {
+    return n;
+}
+
+// In No-PreColoring mode (i.e., -g2 or less) there should be no messages about registers being reserved.
+// NOPC-NOT: Reserving register for ScopeCreationInst in
+
+print((function _1() {
+// PC: Reserving register for ScopeCreationInst in _1
+// PC-NOT: Reserving register for ScopeCreationInst in _1
+    var a = sink(1);
+    return (function _2() {
+// PC: Reserving register for ScopeCreationInst in _2
+// PC-NOT: Reserving register for ScopeCreationInst in _2
+        var b = sink(1);
+        return (function _3() {
+// PC: Reserving register for ScopeCreationInst in _3
+// PC-NOT: Reserving register for ScopeCreationInst in _3
+            var c = sink(1);
+            return (function _4() {
+// PC: Reserving register for ScopeCreationInst in _4
+// PC-NOT: Reserving register for ScopeCreationInst in _4
+                var d = sink(1);
+                return (function _5() {
+// PC: Reserving register for ScopeCreationInst in _5
+// PC-NOT: Reserving register for ScopeCreationInst in _5
+                    var e = sink(1);
+                    return (function _6() {
+// PC: Reserving register for ScopeCreationInst in _6
+// PC-NOT: Reserving register for ScopeCreationInst in _6
+                        var f = sink(1);
+                        return (function _7() {
+// PC: Reserving register for ScopeCreationInst in _7
+// PC-NOT: Reserving register for ScopeCreationInst in _7
+                            var g = sink(1);
+                            return (function _8() {
+// PC: Reserving register for ScopeCreationInst in _8
+// PC-NOT: Reserving register for ScopeCreationInst in _8
+                                var h = sink(1);
+                                return (function _9() {
+// PC: Reserving register for ScopeCreationInst in _9
+// PC-NOT: Reserving register for ScopeCreationInst in _9
+                                    var i = sink(1);
+                                    return (function _10() {
+// PC: Reserving register for ScopeCreationInst in _10
+// PC-NOT: Reserving register for ScopeCreationInst in _10
+                                        var j = sink(1);
+                                        return (function _11() {
+                                            return a + b + c + d + e + f + g + h + i + j + k;
+                                        })()
+                                    })()
+                                })()
+                            })()
+                        })()
+                    })()
+                })()
+            })()
+        })()
+    })()
+})())