Enable component builds for fuzzers

src/handles.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HANDLES_H_
 #define V8_HANDLES_H_
 
 #include "include/v8.h"
 #include "src/base/functional.h"
 #include "src/base/macros.h"
@@ skipping 248 matching lines @@
 // garbage collector will no longer track the object stored in the
 // handle and may deallocate it.  The behavior of accessing a handle
 // for which the handle scope has been deleted is undefined.
 class HandleScope {
  public:
   explicit inline HandleScope(Isolate* isolate);
 
   inline ~HandleScope();
 
   // Counts the number of allocated handles.
-  static int NumberOfHandles(Isolate* isolate);
+  V8_EXPORT_PRIVATE static int NumberOfHandles(Isolate* isolate);
 
   // Create a new handle or lookup a canonical handle.
   V8_INLINE static Object** GetHandle(Isolate* isolate, Object* value);
 
   // Creates a new handle with the given value.
   V8_INLINE static Object** CreateHandle(Isolate* isolate, Object* value);
 
   // Deallocates any extensions used by the current scope.
-  static void DeleteExtensions(Isolate* isolate);
+  V8_EXPORT_PRIVATE static void DeleteExtensions(Isolate* isolate);
 
   static Address current_next_address(Isolate* isolate);
   static Address current_limit_address(Isolate* isolate);
   static Address current_level_address(Isolate* isolate);
 
   // Closes the HandleScope (invalidating all handles
   // created in the scope of the HandleScope) and returns
   // a Handle backed by the parent scope holding the
   // value of the argument handle.
   template <typename T>
@@ skipping 14 matching lines @@
   Isolate* isolate_;
   Object** prev_next_;
   Object** prev_limit_;
 
   // Close the handle scope resetting limits to a previous state.
   static inline void CloseScope(Isolate* isolate,
                                 Object** prev_next,
                                 Object** prev_limit);
 
   // Extend the handle scope making room for more handles.
-  static Object** Extend(Isolate* isolate);
+  V8_EXPORT_PRIVATE static Object** Extend(Isolate* isolate);
 
 #ifdef ENABLE_HANDLE_ZAPPING
   // Zaps the handles in the half-open interval [start, end).
-  static void ZapRange(Object** start, Object** end);
+  V8_EXPORT_PRIVATE static void ZapRange(Object** start, Object** end);
 #endif
 
   friend class v8::HandleScope;
   friend class DeferredHandles;
   friend class DeferredHandleScope;
   friend class HandleScopeImplementer;
   friend class Isolate;
 
   DISALLOW_COPY_AND_ASSIGN(HandleScope);
 };
 
 
 // Forward declarations for CanonicalHandleScope.
 template <typename V>
 class IdentityMap;
 class RootIndexMap;
 
 
 // A CanonicalHandleScope does not open a new HandleScope. It changes the
 // existing HandleScope so that Handles created within are canonicalized.
 // This does not apply to nested inner HandleScopes unless a nested
 // CanonicalHandleScope is introduced. Handles are only canonicalized within
 // the same CanonicalHandleScope, but not across nested ones.
 class CanonicalHandleScope final {
  public:
   explicit CanonicalHandleScope(Isolate* isolate);
   ~CanonicalHandleScope();
 
  private:
-  Object** Lookup(Object* object);
+  V8_EXPORT_PRIVATE Object** Lookup(Object* object);
 
   Isolate* isolate_;
   Zone zone_;
   RootIndexMap* root_index_map_;
   IdentityMap<Object**>* identity_map_;
   // Ordinary nested handle scopes within the current one are not canonical.
   int canonical_level_;
   // We may have nested canonical scopes. Handles are canonical within each one.
   CanonicalHandleScope* prev_canonical_scope_;
 
@@ skipping 53 matching lines @@
     next = limit = NULL;
     sealed_level = level = 0;
     canonical_scope = NULL;
   }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HANDLES_H_