Make MemoryView fields private

Summary:
Cleaning up clang-tidy warnings about how this is being constructed, might as
well make this a class.

Reviewed By: yoney

Differential Revision: D115776510

fbshipit-source-id: 3a06aa8c6a8f8a8b3d6cc1e79a0f4dc831f0b20a

Author: alexmalyshev

cinderx/Jit/deopt.cpp

@@ -340,6 +340,8 @@ const char* deoptReasonName(DeoptReason reason) {
   JIT_ABORT("Invalid DeoptReason {}", static_cast<int>(reason));
 }
 
+MemoryView::MemoryView(const uint64_t* regs) : regs_{regs} {}
+
 BorrowedRef<> MemoryView::readBorrowed(const LiveValue& value) const {
   JIT_CHECK(
       value.value_kind == jit::hir::ValueKind::kObject,
@@ -364,13 +366,23 @@ Ref<> MemoryView::readOwned(const LiveValue& value) const {
   // Everything else is a primitive that has to be boxed into a new object.  A
   // single LiveValue can back several frame-state slots, which all held one
   // object in the interpreter, so box it once and hand out references to that.
-  Ref<>& boxed = boxed_primitives[&value];
+  Ref<>& boxed = boxed_primitives_[&value];
   if (boxed == nullptr) {
     boxed = boxPrimitive(value.value_kind, raw);
   }
   return Ref<>::create(boxed.get());
 }
 
+uint64_t MemoryView::readRaw(const LiveValue& value) const {
+  codegen::PhyLocation loc = value.location;
+  if (loc.isRegister()) {
+    return regs_[loc.loc];
+  }
+  uint64_t frame_pointer = regs_[codegen::arch::reg_frame_pointer_loc.loc];
+  // loc.loc is relative offset from RBP (i.e. negative as stack grows down)
+  return *(reinterpret_cast<uint64_t*>(frame_pointer + loc.loc));
+}
+
 Ref<> profileDeopt(const DeoptMetadata& meta, const MemoryView& mem) {
   BorrowedRef<PyCodeObject> code = meta.innermostFrame().code;
   BCOffset bc_off = meta.innermostFrame().cause_instr_idx;

cinderx/Jit/deopt.h

@@ -222,25 +222,20 @@ struct DeoptMetadata {
 // One instance should cover a whole deopt: reading a primitive live value has
 // to box it, and the cache below is what keeps every frame-state slot backed
 // by that value pointing at a single object.
-struct MemoryView {
-  const uint64_t* regs;
-
-  // Objects materialized for primitive live values, keyed by the value they
-  // came from.  Holds a reference for as long as this view is alive.
-  mutable UnorderedMap<const LiveValue*, Ref<>> boxed_primitives;
+class MemoryView {
+ public:
+  explicit MemoryView(const uint64_t* regs);
 
   BorrowedRef<> readBorrowed(const LiveValue& value) const;
   Ref<> readOwned(const LiveValue& value) const;
+  uint64_t readRaw(const LiveValue& value) const;
 
-  uint64_t readRaw(const LiveValue& value) const {
-    codegen::PhyLocation loc = value.location;
-    if (loc.isRegister()) {
-      return regs[loc.loc];
-    }
-    uint64_t frame_pointer = regs[codegen::arch::reg_frame_pointer_loc.loc];
-    // loc.loc is relative offset from RBP (i.e. negative as stack grows down)
-    return *(reinterpret_cast<uint64_t*>(frame_pointer + loc.loc));
-  }
+ private:
+  const uint64_t* regs_;
+
+  // Objects materialized for primitive live values, keyed by the value they
+  // came from.  Holds a reference for as long as this view is alive.
+  mutable UnorderedMap<const LiveValue*, Ref<>> boxed_primitives_;
 };
 
 // Update `frame` so that execution can resume in the interpreter.