Revert of [d8] Fix the shared-library build (patchset #12 id:20002 of...

Revert of [d8] Fix the shared-library build (patchset #12 id:20002 of https://codereview.chromium.org/2342563002/ )

Reason for revert:
Unblocking roll

Original issue's description:
> [d8] Fix the shared-library build
>
> This commit ensures that the d8 shared library build uses the same logic as
> the standard static build by exporting relevant functions and classes.
>
> BUG=chromium:646337
>
> Committed: https://crrev.com/2c10ca8086a4d595ecf9aa843d2031b068470d65
> Cr-Commit-Position: refs/heads/master@{#39503}

TBR=jochen@chromium.org,vogelheim@chromium.org,bmeurer@chromium.org,titzer@chromium.org,jgruber@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=chromium:646337

Review-Url: https://codereview.chromium.org/2356703003
Cr-Commit-Position: refs/heads/master@{#39526}

BUILD.gn

@@ -115,7 +115,10 @@ config("internal_config") {
   include_dirs = [ "." ]
 
   if (is_component_build) {
-    defines = [ "BUILDING_V8_SHARED" ]
+    defines = [
+      "V8_SHARED",
+      "BUILDING_V8_SHARED",
+    ]
   }
 }
 
@@ -139,7 +142,10 @@ config("libsampler_config") {
 # itself.
 config("external_config") {
   if (is_component_build) {
-    defines = [ "USING_V8_SHARED" ]
+    defines = [
+      "V8_SHARED",
+      "USING_V8_SHARED",
+    ]
   }
   include_dirs = [ "include" ]
   if (v8_enable_inspector_override) {
@@ -2383,7 +2389,6 @@ if (is_component_build) {
 
 v8_executable("d8") {
   sources = [
-    "$target_gen_dir/d8-js.cc",
     "src/d8.cc",
     "src/d8.h",
   ]
@@ -2411,6 +2416,9 @@ v8_executable("d8") {
     sources += [ "src/d8-windows.cc" ]
   }
 
+  if (!is_component_build) {
+    sources += [ "$target_gen_dir/d8-js.cc" ]
+  }
   if (v8_enable_i18n_support) {
     deps += [ "//third_party/icu" ]
   }

include/v8.h

@@ -51,7 +51,7 @@
 #else  // V8_OS_WIN
 
 // Setup for Linux shared library export.
-#if V8_HAS_ATTRIBUTE_VISIBILITY
+#if V8_HAS_ATTRIBUTE_VISIBILITY && defined(V8_SHARED)
 # ifdef BUILDING_V8_SHARED
 #  define V8_EXPORT __attribute__ ((visibility("default")))
 # else

src/allocation.h

@@ -13,10 +13,10 @@ namespace internal {
 // Called when allocation routines fail to allocate.
 // This function should not return, but should terminate the current
 // processing.
-V8_EXPORT_PRIVATE void FatalProcessOutOfMemory(const char* message);
+void FatalProcessOutOfMemory(const char* message);
 
 // Superclass for classes managed with new & delete.
-class V8_EXPORT_PRIVATE Malloced {
+class Malloced {
  public:
   void* operator new(size_t size) { return New(size); }
   void  operator delete(void* p) { Delete(p); }
@@ -72,7 +72,7 @@ void DeleteArray(T* array) {
 // The normal strdup functions use malloc.  These versions of StrDup
 // and StrNDup uses new and calls the FatalProcessOutOfMemory handler
 // if allocation fails.
-V8_EXPORT_PRIVATE char* StrDup(const char* str);
+char* StrDup(const char* str);
 char* StrNDup(const char* str, int n);
 
 

src/basic-block-profiler.h

@@ -11,7 +11,6 @@
 #include <vector>
 
 #include "src/base/macros.h"
-#include "src/globals.h"
 
 namespace v8 {
 namespace internal {
@@ -59,16 +58,15 @@ class BasicBlockProfiler {
   const DataList* data_list() { return &data_list_; }
 
  private:
-  friend V8_EXPORT_PRIVATE std::ostream& operator<<(
-      std::ostream& os, const BasicBlockProfiler& s);
+  friend std::ostream& operator<<(std::ostream& os,
+                                  const BasicBlockProfiler& s);
 
   DataList data_list_;
 
   DISALLOW_COPY_AND_ASSIGN(BasicBlockProfiler);
 };
 
-V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
-                                           const BasicBlockProfiler& s);
+std::ostream& operator<<(std::ostream& os, const BasicBlockProfiler& s);
 std::ostream& operator<<(std::ostream& os, const BasicBlockProfiler::Data& s);
 
 }  // namespace internal

src/d8.gyp

@@ -49,18 +49,10 @@
       'sources': [
         'd8.h',
         'd8.cc',
-        '<(SHARED_INTERMEDIATE_DIR)/d8-js.cc',
       ],
       'conditions': [
         [ 'want_separate_host_toolset==1', {
           'toolsets': [ 'target', ],
-          'dependencies': [
-            'd8_js2c#host',
-          ],
-        }, {
-          'dependencies': [
-            'd8_js2c',
-          ],
         }],
         ['(OS=="linux" or OS=="mac" or OS=="freebsd" or OS=="netbsd" \
            or OS=="openbsd" or OS=="solaris" or OS=="android" \
@@ -71,7 +63,19 @@
           'sources': [ 'd8-windows.cc', ]
         }],
         [ 'component!="shared_library"', {
+          'sources': [
+            '<(SHARED_INTERMEDIATE_DIR)/d8-js.cc',
+          ],
           'conditions': [
+            [ 'want_separate_host_toolset==1', {
+              'dependencies': [
+                'd8_js2c#host',
+              ],
+            }, {
+              'dependencies': [
+                'd8_js2c',
+              ],
+            }],
             [ 'v8_postmortem_support=="true"', {
               'xcode_settings': {
                 'OTHER_LDFLAGS': [

src/d8.h

@@ -5,10 +5,15 @@
 #ifndef V8_D8_H_
 #define V8_D8_H_
 
+#ifndef V8_SHARED
 #include "src/allocation.h"
 #include "src/base/hashmap.h"
 #include "src/base/platform/time.h"
 #include "src/list.h"
+#else
+#include "include/v8.h"
+#include "src/base/compiler-specific.h"
+#endif  // !V8_SHARED
 
 #include "src/base/once.h"
 
@@ -16,6 +21,7 @@
 namespace v8 {
 
 
+#ifndef V8_SHARED
 // A single counter in a counter collection.
 class Counter {
  public:
@@ -84,14 +90,17 @@ class CounterMap {
   static bool Match(void* key1, void* key2);
   base::HashMap hash_map_;
 };
+#endif  // !V8_SHARED
 
 
 class SourceGroup {
  public:
   SourceGroup() :
+#ifndef V8_SHARED
       next_semaphore_(0),
       done_semaphore_(0),
       thread_(NULL),
+#endif  // !V8_SHARED
       argv_(NULL),
       begin_offset_(0),
       end_offset_(0) {}
@@ -107,6 +116,7 @@ class SourceGroup {
 
   void Execute(Isolate* isolate);
 
+#ifndef V8_SHARED
   void StartExecuteInThread();
   void WaitForThread();
   void JoinThread();
@@ -131,6 +141,7 @@ class SourceGroup {
   base::Semaphore next_semaphore_;
   base::Semaphore done_semaphore_;
   base::Thread* thread_;
+#endif  // !V8_SHARED
 
   void ExitShell(int exit_code);
   Local<String> ReadFile(Isolate* isolate, const char* name);
@@ -140,6 +151,7 @@ class SourceGroup {
   int end_offset_;
 };
 
+#ifndef V8_SHARED
 enum SerializationTag {
   kSerializationTagUndefined,
   kSerializationTagNull,
@@ -255,6 +267,7 @@ class Worker {
   char* script_;
   base::Atomic32 running_;
 };
+#endif  // !V8_SHARED
 
 
 class ShellOptions {
@@ -311,7 +324,12 @@ class ShellOptions {
   const char* trace_config;
 };
 
+#ifdef V8_SHARED
+class Shell {
+#else
 class Shell : public i::AllStatic {
+#endif  // V8_SHARED
+
  public:
   enum SourceType { SCRIPT, MODULE };
 
@@ -333,6 +351,7 @@ class Shell : public i::AllStatic {
   static void CollectGarbage(Isolate* isolate);
   static void EmptyMessageQueues(Isolate* isolate);
 
+#ifndef V8_SHARED
   // TODO(binji): stupid implementation for now. Is there an easy way to hash an
   // object for use in base::HashMap? By pointer?
   typedef i::List<Local<Object>> ObjectList;
@@ -353,6 +372,7 @@ class Shell : public i::AllStatic {
   static void MapCounters(v8::Isolate* isolate, const char* name);
 
   static void PerformanceNow(const v8::FunctionCallbackInfo<v8::Value>& args);
+#endif  // !V8_SHARED
 
   static void RealmCurrent(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void RealmOwner(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -430,6 +450,7 @@ class Shell : public i::AllStatic {
  private:
   static Global<Context> evaluation_context_;
   static base::OnceType quit_once_;
+#ifndef V8_SHARED
   static Global<Function> stringify_function_;
   static CounterMap* counter_map_;
   // We statically allocate a set of local counters to be used if we
@@ -448,6 +469,7 @@ class Shell : public i::AllStatic {
   static void WriteIgnitionDispatchCountersFile(v8::Isolate* isolate);
   static Counter* GetCounter(const char* name, bool is_histogram);
   static Local<String> Stringify(Isolate* isolate, Local<Value> value);
+#endif  // !V8_SHARED
   static void Initialize(Isolate* isolate);
   static void RunShell(Isolate* isolate);
   static bool SetOptions(int argc, char* argv[]);

src/factory.h

@@ -28,8 +28,9 @@ class Factory final {
                              byte kind);
 
   // Allocates a fixed array initialized with undefined values.
-  V8_EXPORT_PRIVATE Handle<FixedArray> NewFixedArray(
-      int size, PretenureFlag pretenure = NOT_TENURED);
+  Handle<FixedArray> NewFixedArray(
+      int size,
+      PretenureFlag pretenure = NOT_TENURED);
 
   // Allocate a new fixed array with non-existing entries (the hole).
   Handle<FixedArray> NewFixedArrayWithHoles(
@@ -164,8 +165,9 @@ class Factory final {
 
   // UTF8 strings are pretenured when used for regexp literal patterns and
   // flags in the parser.
-  MUST_USE_RESULT V8_EXPORT_PRIVATE MaybeHandle<String> NewStringFromUtf8(
-      Vector<const char> str, PretenureFlag pretenure = NOT_TENURED);
+  MUST_USE_RESULT MaybeHandle<String> NewStringFromUtf8(
+      Vector<const char> str,
+      PretenureFlag pretenure = NOT_TENURED);
 
   MUST_USE_RESULT MaybeHandle<String> NewStringFromTwoByte(
       Vector<const uc16> str,
@@ -455,11 +457,11 @@ class Factory final {
   }
 
   // Create a JSArray with the given elements.
-  V8_EXPORT_PRIVATE Handle<JSArray> NewJSArrayWithElements(
-      Handle<FixedArrayBase> elements, ElementsKind elements_kind, int length,
-      PretenureFlag pretenure = NOT_TENURED);
+  Handle<JSArray> NewJSArrayWithElements(Handle<FixedArrayBase> elements,
+                                         ElementsKind elements_kind, int length,
+                                         PretenureFlag pretenure = NOT_TENURED);
 
-  V8_EXPORT_PRIVATE Handle<JSArray> NewJSArrayWithElements(
+  Handle<JSArray> NewJSArrayWithElements(
       Handle<FixedArrayBase> elements,
       ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND,
       PretenureFlag pretenure = NOT_TENURED) {

src/flag-definitions.h

@@ -23,21 +23,14 @@
 // this will just be an extern declaration, but for a readonly flag we let the
 // compiler make better optimizations by giving it the value.
 #if defined(FLAG_MODE_DECLARE)
-#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
-  V8_EXPORT_PRIVATE extern ctype FLAG_##nam;
+#define FLAG_FULL(ftype, ctype, nam, def, cmt) extern ctype FLAG_##nam;
 #define FLAG_READONLY(ftype, ctype, nam, def, cmt) \
   static ctype const FLAG_##nam = def;
 
 // We want to supply the actual storage and value for the flag variable in the
 // .cc file.  We only do this for writable flags.
 #elif defined(FLAG_MODE_DEFINE)
-#ifdef USING_V8_SHARED
-#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
-  V8_EXPORT_PRIVATE extern ctype FLAG_##nam;
-#else
-#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
-  V8_EXPORT_PRIVATE ctype FLAG_##nam = def;
-#endif
+#define FLAG_FULL(ftype, ctype, nam, def, cmt) ctype FLAG_##nam = def;
 
 // We need to define all of our default values so that the Flag structure can
 // access them by pointer.  These are just used internally inside of one .cc,

src/globals.h

@@ -14,32 +14,6 @@
 #include "src/base/logging.h"
 #include "src/base/macros.h"
 
-#ifdef V8_OS_WIN
-
-// Setup for Windows shared library export.
-#ifdef BUILDING_V8_SHARED
-#define V8_EXPORT_PRIVATE __declspec(dllexport)
-#elif USING_V8_SHARED
-#define V8_EXPORT_PRIVATE __declspec(dllimport)
-#else
-#define V8_EXPORT_PRIVATE
-#endif  // BUILDING_V8_SHARED
-
-#else  // V8_OS_WIN
-
-// Setup for Linux shared library export.
-#if V8_HAS_ATTRIBUTE_VISIBILITY
-#ifdef BUILDING_V8_SHARED
-#define V8_EXPORT_PRIVATE __attribute__((visibility("default")))
-#else
-#define V8_EXPORT_PRIVATE
-#endif
-#else
-#define V8_EXPORT_PRIVATE
-#endif
-
-#endif  // V8_OS_WIN
-
 // Unfortunately, the INFINITY macro cannot be used with the '-pedantic'
 // warning flag and certain versions of GCC due to a bug:
 // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=11931

src/heap/heap.h

@@ -2426,7 +2426,7 @@ class AllSpaces BASE_EMBEDDED {
 
 // Space iterator for iterating over all old spaces of the heap: Old space
 // and code space.  Returns each space in turn, and null when it is done.
-class V8_EXPORT_PRIVATE OldSpaces BASE_EMBEDDED {
+class OldSpaces BASE_EMBEDDED {
  public:
   explicit OldSpaces(Heap* heap) : heap_(heap), counter_(OLD_SPACE) {}
   OldSpace* next();

src/heap/incremental-marking.h

@@ -154,8 +154,8 @@ class IncrementalMarking {
   INLINE(void RecordWriteOfCodeEntry(JSFunction* host, Object** slot,
                                      Code* value));
 
-  V8_EXPORT_PRIVATE void RecordWriteSlow(HeapObject* obj, Object** slot,
-                                         Object* value);
+
+  void RecordWriteSlow(HeapObject* obj, Object** slot, Object* value);
   void RecordWriteIntoCodeSlow(Code* host, RelocInfo* rinfo, Object* value);
   void RecordWriteOfCodeEntrySlow(JSFunction* host, Object** slot, Code* value);
   void RecordCodeTargetPatch(Code* host, Address pc, HeapObject* value);

src/heap/mark-compact.h

@@ -776,7 +776,8 @@ class EvacuationScope BASE_EMBEDDED {
   MarkCompactCollector* collector_;
 };
 
-V8_EXPORT_PRIVATE const char* AllocationSpaceName(AllocationSpace space);
+
+const char* AllocationSpaceName(AllocationSpace space);
 }  // namespace internal
 }  // namespace v8
 

src/heap/spaces.h

@@ -463,7 +463,7 @@ class MemoryChunk {
   }
   inline LocalArrayBufferTracker* local_tracker() { return local_tracker_; }
 
-  V8_EXPORT_PRIVATE void AllocateOldToNewSlots();
+  void AllocateOldToNewSlots();
   void ReleaseOldToNewSlots();
   void AllocateOldToOldSlots();
   void ReleaseOldToOldSlots();
@@ -1430,7 +1430,7 @@ class MemoryAllocator {
 //       method which is used to avoid using virtual functions
 //       iterating a specific space.
 
-class V8_EXPORT_PRIVATE ObjectIterator : public Malloced {
+class ObjectIterator : public Malloced {
  public:
   virtual ~ObjectIterator() {}
   virtual HeapObject* Next() = 0;
@@ -1481,7 +1481,7 @@ class PageRange {
 // If objects are allocated in the page during iteration the iterator may
 // or may not iterate over those objects.  The caller must create a new
 // iterator in order to be sure to visit these new objects.
-class V8_EXPORT_PRIVATE HeapObjectIterator : public ObjectIterator {
+class HeapObjectIterator : public ObjectIterator {
  public:
   // Creates a new object iterator in a given space.
   explicit HeapObjectIterator(PagedSpace* space);

src/inspector/BUILD.gn

@@ -106,7 +106,10 @@ config("inspector_config") {
     ]
   }
   if (is_component_build) {
-    defines = [ "BUILDING_V8_SHARED" ]
+    defines = [
+      "V8_SHARED",
+      "BUILDING_V8_SHARED",
+    ]
   }
 }
 

src/interpreter/interpreter.h

@@ -56,7 +56,7 @@ class Interpreter {
   void TraceCodegen(Handle<Code> code);
   const char* LookupNameOfBytecodeHandler(Code* code);
 
-  V8_EXPORT_PRIVATE Local<v8::Object> GetDispatchCountersObject();
+  Local<v8::Object> GetDispatchCountersObject();
 
   Address dispatch_table_address() {
     return reinterpret_cast<Address>(&dispatch_table_[0]);

src/ostreams.h

@@ -13,7 +13,6 @@
 
 #include "include/v8config.h"
 #include "src/base/macros.h"
-#include "src/globals.h"
 
 namespace v8 {
 namespace internal {
@@ -34,7 +33,7 @@ class OFStreamBase : public std::streambuf {
 
 
 // An output stream writing to a file.
-class V8_EXPORT_PRIVATE OFStream : public std::ostream {
+class OFStream : public std::ostream {
  public:
   explicit OFStream(FILE* f);
   virtual ~OFStream();

src/snapshot/natives.h

@@ -22,15 +22,8 @@ enum NativeType {
   TEST
 };
 
-// Extra handling for V8_EXPORT_PRIVATE in combination with USING_V8_SHARED
-// since definition of methods of classes marked as dllimport is not allowed.
 template <NativeType type>
-#ifdef USING_V8_SHARED
 class NativesCollection {
-#else
-class V8_EXPORT_PRIVATE NativesCollection {
-#endif  // USING_V8_SHARED
-
  public:
   // The following methods are implemented in js2c-generated code:
 

src/utils.h

@@ -437,7 +437,7 @@ void init_memcopy_functions(Isolate* isolate);
 const int kMinComplexMemCopy = 64;
 
 // Copy memory area. No restrictions.
-V8_EXPORT_PRIVATE void MemMove(void* dest, const void* src, size_t size);
+void MemMove(void* dest, const void* src, size_t size);
 typedef void (*MemMoveFunction)(void* dest, const void* src, size_t size);
 
 // Keep the distinction of "move" vs. "copy" for the benefit of other
@@ -459,8 +459,7 @@ V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
   (*memcopy_uint8_function)(reinterpret_cast<uint8_t*>(dest),
                             reinterpret_cast<const uint8_t*>(src), size);
 }
-V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
-                                         size_t size) {
+V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
   memmove(dest, src, size);
 }
 
@@ -489,8 +488,7 @@ V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
   (*memcopy_uint8_function)(reinterpret_cast<uint8_t*>(dest),
                             reinterpret_cast<const uint8_t*>(src), size);
 }
-V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
-                                         size_t size) {
+V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
   memmove(dest, src, size);
 }
 #else
@@ -498,8 +496,7 @@ V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
 V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
   memcpy(dest, src, size);
 }
-V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
-                                         size_t size) {
+V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
   memmove(dest, src, size);
 }
 const int kMinComplexMemCopy = 16 * kPointerSize;

src/v8.gyp

@@ -61,10 +61,12 @@
             '..',
           ],
           'defines': [
+            'V8_SHARED',
             'BUILDING_V8_SHARED',
           ],
           'direct_dependent_settings': {
             'defines': [
+              'V8_SHARED',
               'USING_V8_SHARED',
             ],
           },
@@ -162,10 +164,12 @@
         }],
         ['component=="shared_library"', {
           'defines': [
+            'V8_SHARED',
             'BUILDING_V8_SHARED',
           ],
           'direct_dependent_settings': {
             'defines': [
+              'V8_SHARED',
               'USING_V8_SHARED',
             ],
           },
@@ -255,6 +259,7 @@
         ['component=="shared_library"', {
           'defines': [
             'BUILDING_V8_SHARED',
+            'V8_SHARED',
           ],
         }],
       ]
@@ -281,10 +286,12 @@
             }],
             ['component=="shared_library"', {
               'defines': [
+                'V8_SHARED',
                 'BUILDING_V8_SHARED',
               ],
               'direct_dependent_settings': {
                 'defines': [
+                  'V8_SHARED',
                   'USING_V8_SHARED',
                 ],
               },
@@ -1706,6 +1713,7 @@
         ['component=="shared_library"', {
           'defines': [
             'BUILDING_V8_SHARED',
+            'V8_SHARED',
           ],
         }],
         ['v8_postmortem_support=="true"', {

src/wasm/wasm-js.h

@@ -5,8 +5,13 @@
 #ifndef V8_WASM_JS_H_
 #define V8_WASM_JS_H_
 
+#ifndef V8_SHARED
 #include "src/allocation.h"
 #include "src/base/hashmap.h"
+#else
+#include "include/v8.h"
+#include "src/base/compiler-specific.h"
+#endif  // !V8_SHARED
 
 namespace v8 {
 namespace internal {