Track global cells as special side effects in GVN.

src/hydrogen-gvn.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 349 matching lines @@
   for (int i = 0; i < kNumberOfTrackedSideEffects; i++) {
     if (side_effects.ContainsFlag(GVNFlagFromInt(i))) {
       if (data_[i] == NULL) count_++;
       data_[i] = instr;
     }
   }
 }
 
 
 SideEffects SideEffectsTracker::ComputeChanges(HInstruction* instr) {
+  int index;
   SideEffects result(instr->ChangesFlags());
+  if (result.ContainsFlag(kGlobalVars)) {
+    if (instr->IsStoreGlobalCell() &&
+        ComputeGlobalVar(HStoreGlobalCell::cast(instr)->cell(), &index)) {
+      result.RemoveFlag(kGlobalVars);
+      result.AddSpecial(GlobalVar(index));
+    } else {
+      for (index = 0; index < kNumberOfGlobalVars; ++index) {
+        result.AddSpecial(GlobalVar(index));
+      }
+    }
+  }
   if (result.ContainsFlag(kInobjectFields)) {
-    int index;
     if (instr->IsStoreNamedField() &&
         ComputeInobjectField(HStoreNamedField::cast(instr)->access(), &index)) {
       result.RemoveFlag(kInobjectFields);
-      result.AddSpecial(index);
+      result.AddSpecial(InobjectField(index));
     } else {
-      result.AddAllSpecial();
+      for (index = 0; index < kNumberOfInobjectFields; ++index) {
+        result.AddSpecial(InobjectField(index));
+      }
     }
   }
   return result;
 }
 
 
 SideEffects SideEffectsTracker::ComputeDependsOn(HInstruction* instr) {
+  int index;
   SideEffects result(instr->DependsOnFlags());
+  if (result.ContainsFlag(kGlobalVars)) {
+    if (instr->IsLoadGlobalCell() &&
+        ComputeGlobalVar(HLoadGlobalCell::cast(instr)->cell(), &index)) {
+      result.RemoveFlag(kGlobalVars);
+      result.AddSpecial(GlobalVar(index));
+    } else {
+      for (index = 0; index < kNumberOfGlobalVars; ++index) {
+        result.AddSpecial(GlobalVar(index));
+      }
+    }
+  }
   if (result.ContainsFlag(kInobjectFields)) {
-    int index;
     if (instr->IsLoadNamedField() &&
         ComputeInobjectField(HLoadNamedField::cast(instr)->access(), &index)) {
       result.RemoveFlag(kInobjectFields);
-      result.AddSpecial(index);
+      result.AddSpecial(InobjectField(index));
     } else {
-      result.AddAllSpecial();
+      for (index = 0; index < kNumberOfInobjectFields; ++index) {
+        result.AddSpecial(InobjectField(index));
+      }
     }
   }
   return result;
 }
 
 
 void SideEffectsTracker::PrintSideEffectsTo(StringStream* stream,
                                           SideEffects side_effects) const {
   const char* separator = "";
   stream->Add("[");
   for (int bit = 0; bit < kNumberOfFlags; ++bit) {
     GVNFlag flag = GVNFlagFromInt(bit);
     if (side_effects.ContainsFlag(flag)) {
       stream->Add(separator);
       separator = ", ";
       switch (flag) {
 #define DECLARE_FLAG(Type)      \
         case k##Type:           \
           stream->Add(#Type);   \
           break;
 GVN_TRACKED_FLAG_LIST(DECLARE_FLAG)
 GVN_UNTRACKED_FLAG_LIST(DECLARE_FLAG)
 #undef DECLARE_FLAG
         default:
             break;
       }
     }
   }
+  for (int index = 0; index < num_global_vars_; ++index) {
+    if (side_effects.ContainsSpecial(GlobalVar(index))) {
+      stream->Add(separator);
+      separator = ", ";
+      stream->Add("[%p]", *global_vars_[index].handle());

[Michael Starzinger, 2014/03/06 15:45:28]

See comment below.

[Benedikt Meurer, 2014/03/07 06:23:58]

Done.

+    }
+  }
   for (int index = 0; index < num_inobject_fields_; ++index) {
-    if (side_effects.ContainsSpecial(index)) {
+    if (side_effects.ContainsSpecial(InobjectField(index))) {
       stream->Add(separator);
       separator = ", ";
       inobject_fields_[index].PrintTo(stream);
     }
   }
   stream->Add("]");
 }
 
 
+bool SideEffectsTracker::ComputeGlobalVar(Unique<Cell> cell, int* index) {
+  for (int i = 0; i < num_global_vars_; ++i) {
+    if (cell == global_vars_[i]) {
+      *index = i;
+      return true;
+    }
+  }
+  if (num_global_vars_ < kNumberOfGlobalVars) {
+    if (FLAG_trace_gvn) {
+      HeapStringAllocator allocator;
+      StringStream stream(&allocator);
+      stream.Add("Tracking global var [%p] (mapped to index %d)\n",
+                 *cell.handle(), num_global_vars_);

[Michael Starzinger, 2014/03/06 15:45:28]

Dereferencing the handle here will not work if we are on the compiler thread. We
could print the hashcode of the Unique instead. On the other hand, cells are not
relocated, so we could broaden the assert.

[Benedikt Meurer, 2014/03/07 06:23:58]

Done.

+      stream.OutputToStdOut();
+    }
+    *index = num_global_vars_;
+    global_vars_[num_global_vars_++] = cell;
+    return true;
+  }
+  return false;
+}
+
+
 bool SideEffectsTracker::ComputeInobjectField(HObjectAccess access,
                                               int* index) {
   for (int i = 0; i < num_inobject_fields_; ++i) {
     if (access.Equals(inobject_fields_[i])) {
       *index = i;
       return true;
     }
   }
-  if (num_inobject_fields_ < SideEffects::kNumberOfSpecials) {
+  if (num_inobject_fields_ < kNumberOfInobjectFields) {
     if (FLAG_trace_gvn) {
       HeapStringAllocator allocator;
       StringStream stream(&allocator);
       stream.Add("Tracking inobject field access ");
       access.PrintTo(&stream);
-      stream.Add(" (mapped to special index %d)\n", num_inobject_fields_);
+      stream.Add(" (mapped to index %d)\n", num_inobject_fields_);
       stream.OutputToStdOut();
     }
     *index = num_inobject_fields_;
     inobject_fields_[num_inobject_fields_++] = access;
     return true;
   }
   return false;
 }
 
 
@@ skipping 412 matching lines @@
                                                       dominated);
         successor_map->Kill(side_effects_on_all_paths);
         successor_dominators->Kill(side_effects_on_all_paths);
       }
     }
     current = next;
   }
 }
 
 } }  // namespace v8::internal