[ext-code-space] Migrate FeedbackVector::optimized_code field to CodeT

Bug: v8:11880
Change-Id: I6a0b6bc1b4a7c75bfca2e4f611f45012474309a0
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2968414Reviewed-by: Toon Verwaest <verwaest@chromium.org>
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#75235}

src/builtins/builtins-lazy-gen.cc

@@ -7,6 +7,7 @@
 #include "src/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/common/globals.h"
+#include "src/objects/code-inl.h"
 #include "src/objects/feedback-vector.h"
 #include "src/objects/shared-function-info.h"
 
@@ -75,15 +76,16 @@ void LazyBuiltinsAssembler::MaybeTailCallOptimizedCodeSlot(
     Label heal_optimized_code_slot(this);
     TNode<MaybeObject> maybe_optimized_code_entry = LoadMaybeWeakObjectField(
         feedback_vector, FeedbackVector::kMaybeOptimizedCodeOffset);
-    // Optimized code slot is a weak reference.
-    TNode<Code> optimized_code = CAST(GetHeapObjectAssumeWeak(
+
+    // Optimized code slot is a weak reference to CodeT object.
+    TNode<CodeT> code_t = CAST(GetHeapObjectAssumeWeak(
         maybe_optimized_code_entry, &heal_optimized_code_slot));
+    TNode<Code> optimized_code = FromCodeT(code_t);
 
     // Check if the optimized code is marked for deopt. If it is, call the
     // runtime to clear it.
     TNode<CodeDataContainer> code_data_container =
-        CAST(LoadObjectField(optimized_code, Code::kCodeDataContainerOffset));
-
+        CodeDataContainerFromCodeT(code_t);
     TNode<Int32T> code_kind_specific_flags = LoadObjectField<Int32T>(
         code_data_container, CodeDataContainer::kKindSpecificFlagsOffset);
     GotoIf(IsSetWord32<Code::MarkedForDeoptimizationField>(

src/builtins/x64/builtins-x64.cc

@@ -958,11 +958,6 @@ static void TailCallOptimizedCodeSlot(MacroAssembler* masm,
   // Check if the optimized code is marked for deopt. If it is, call the
   // runtime to clear it.
   if (V8_EXTERNAL_CODE_SPACE_BOOL) {
-    // At this point |optimized_code_entry| is still Code object, so "convert"
-    // it to CodeT.
-    __ LoadTaggedPointerField(
-        optimized_code_entry,
-        FieldOperand(optimized_code_entry, Code::kCodeDataContainerOffset));
     __ AssertCodeDataContainer(optimized_code_entry);
     __ testl(FieldOperand(optimized_code_entry,
                           CodeDataContainer::kKindSpecificFlagsOffset),

src/objects/feedback-vector-inl.h

@@ -118,8 +118,10 @@ Code FeedbackVector::optimized_code() const {
   MaybeObject slot = maybe_optimized_code(kAcquireLoad);
   DCHECK(slot->IsWeakOrCleared());
   HeapObject heap_object;
-  Code code =
-      slot->GetHeapObject(&heap_object) ? Code::cast(heap_object) : Code();
+  Code code;
+  if (slot->GetHeapObject(&heap_object)) {
+    code = FromCodeT(CodeT::cast(heap_object));
+  }
   // It is possible that the maybe_optimized_code slot is cleared but the
   // optimization tier hasn't been updated yet. We update the tier when we
   // execute the function next time / when we create new closure.

src/objects/feedback-vector.cc

@@ -394,7 +394,7 @@ void FeedbackVector::SetOptimizedCode(Handle<FeedbackVector> vector,
   // re-mark the function for non-concurrent optimization after an OSR. We
   // should avoid these cases and also check that marker isn't
   // kCompileOptimized or kCompileOptimizedConcurrent.
-  vector->set_maybe_optimized_code(HeapObjectReference::Weak(*code),
+  vector->set_maybe_optimized_code(HeapObjectReference::Weak(ToCodeT(*code)),
                                    kReleaseStore);
   int32_t state = vector->flags();
   state = OptimizationTierBits::update(state, GetTierForCodeKind(code->kind()));
@@ -474,7 +474,7 @@ void FeedbackVector::EvictOptimizedCodeMarkedForDeoptimization(
     return;
   }
 
-  Code code = Code::cast(slot->GetHeapObject());
+  Code code = FromCodeT(CodeT::cast(slot->GetHeapObject()));
   if (code.marked_for_deoptimization()) {
     Deoptimizer::TraceEvictFromOptimizedCodeCache(shared, reason);
     if (!code.deopt_already_counted()) {

src/objects/feedback-vector.tq

@@ -22,7 +22,8 @@ extern class FeedbackVector extends HeapObject {
   // Padding was necessary for GCMole.
   flags: FeedbackVectorFlags;
   shared_function_info: SharedFunctionInfo;
-  maybe_optimized_code: Weak<Code>;
+  @if(V8_EXTERNAL_CODE_SPACE) maybe_optimized_code: Weak<CodeDataContainer>;
+  @ifnot(V8_EXTERNAL_CODE_SPACE) maybe_optimized_code: Weak<Code>;
   closure_feedback_cell_array: ClosureFeedbackCellArray;
   @cppRelaxedLoad raw_feedback_slots[length]: MaybeObject;
 }

src/runtime/runtime-test.cc

@@ -590,12 +590,13 @@ RUNTIME_FUNCTION(Runtime_GetOptimizationStatus) {
   }
 
   if (function->HasAttachedOptimizedCode()) {
-    if (function->code().marked_for_deoptimization()) {
+    Code code = function->code();
+    if (code.marked_for_deoptimization()) {
       status |= static_cast<int>(OptimizationStatus::kMarkedForDeoptimization);
     } else {
       status |= static_cast<int>(OptimizationStatus::kOptimized);
     }
-    if (function->code().is_turbofanned()) {
+    if (code.is_turbofanned()) {
       status |= static_cast<int>(OptimizationStatus::kTurboFanned);
     }
   }

test/cctest/test-heap-profiler.cc

@@ -4103,7 +4103,7 @@ TEST(WeakReference) {
           .Build();
   CHECK(code->IsCode());
 
-  fv->set_maybe_optimized_code(i::HeapObjectReference::Weak(*code),
+  fv->set_maybe_optimized_code(i::HeapObjectReference::Weak(ToCodeT(*code)),
                                v8::kReleaseStore);
   fv->set_flags(i::FeedbackVector::OptimizationTierBits::encode(
                     i::OptimizationTier::kTopTier) |