Make HeapObjectHeader and FinalizedHeapObjectHeader visible in the shared object for newer GCC.

Source/heap/Heap.h

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 203 matching lines @@
 private:
     friend class Heap;
     friend class ThreadHeap<Header>;
 
     LargeHeapObject<Header>* m_next;
 };
 
 // The BasicObjectHeader is the minimal object header. It is used when
 // encountering heap space of size allocationGranularity to mark it as
 // as freelist entry.
-class BasicObjectHeader {
+class HEAP_EXPORT BasicObjectHeader {
 public:
     NO_SANITIZE_ADDRESS
     explicit BasicObjectHeader(size_t encodedSize)
         : m_size(encodedSize) { }
 
     static size_t freeListEncodedSize(size_t size) { return size | freeListMask; }
 
     NO_SANITIZE_ADDRESS
     bool isFree() { return m_size & freeListMask; }
 
     NO_SANITIZE_ADDRESS
     size_t size() const { return m_size & sizeMask; }
 
 protected:
     size_t m_size;
 };
 
 // Our heap object layout is layered with the HeapObjectHeader closest
 // to the payload, this can be wrapped in a FinalizedObjectHeader if the
 // object is on the GeneralHeap and not on a specific TypedHeap.
 // Finally if the object is a large object (> blinkPageSize/2) then it is
 // wrapped with a LargeObjectHeader.
 //
 // Object memory layout:
 // [ LargeObjectHeader | ] [ FinalizedObjectHeader | ] HeapObjectHeader | payload
 // The [ ] notation denotes that the LargeObjectHeader and the FinalizedObjectHeader
 // are independently optional.
-class HeapObjectHeader : public BasicObjectHeader {
+class HEAP_EXPORT HeapObjectHeader : public BasicObjectHeader {
 public:
     NO_SANITIZE_ADDRESS
     explicit HeapObjectHeader(size_t encodedSize)
         : BasicObjectHeader(encodedSize)
 #ifndef NDEBUG
         , m_magic(magic)
 #endif
     { }
 
     NO_SANITIZE_ADDRESS
@@ skipping 17 matching lines @@
     inline void setDebugMark();
     inline void clearDebugMark();
     inline bool hasDebugMark() const;
 
     // Zap magic number with a new magic number that means there was once an
     // object allocated here, but it was freed because nobody marked it during
     // GC.
     void zapMagic();
 
     static void finalize(const GCInfo*, Address, size_t);
-    HEAP_EXPORT static HeapObjectHeader* fromPayload(const void*);
+    static HeapObjectHeader* fromPayload(const void*);
 
     static const intptr_t magic = 0xc0de247;
     static const intptr_t zappedMagic = 0xC0DEdead;
     // The zap value for vtables should be < 4K to ensure it cannot be
     // used for dispatch.
     static const intptr_t zappedVTable = 0xd0d;
 
 private:
 #ifndef NDEBUG
     intptr_t m_magic;
 #endif
 };
 
 const size_t objectHeaderSize = sizeof(HeapObjectHeader);
 
 // Each object on the GeneralHeap needs to carry a pointer to its
 // own GCInfo structure for tracing and potential finalization.
-class FinalizedHeapObjectHeader : public HeapObjectHeader {
+class HEAP_EXPORT FinalizedHeapObjectHeader : public HeapObjectHeader {
 public:
     NO_SANITIZE_ADDRESS
     FinalizedHeapObjectHeader(size_t encodedSize, const GCInfo* gcInfo)
         : HeapObjectHeader(encodedSize)
         , m_gcInfo(gcInfo)
     {
     }
 
     inline Address payload();
     inline size_t payloadSize();
 
     NO_SANITIZE_ADDRESS
     const GCInfo* gcInfo() { return m_gcInfo; }
 
     NO_SANITIZE_ADDRESS
     TraceCallback traceCallback() { return m_gcInfo->m_trace; }
 
     void finalize();
 
     NO_SANITIZE_ADDRESS
     inline bool hasFinalizer() { return m_gcInfo->hasFinalizer(); }
 
-    HEAP_EXPORT static FinalizedHeapObjectHeader* fromPayload(const void*);
+    static FinalizedHeapObjectHeader* fromPayload(const void*);
 
 private:
     const GCInfo* m_gcInfo;
 };
 
 const size_t finalizedHeaderSize = sizeof(FinalizedHeapObjectHeader);
 
 class FreeListEntry : public HeapObjectHeader {
 public:
     NO_SANITIZE_ADDRESS
@@ skipping 1340 matching lines @@
 // to export. This forces it to export all the methods from ThreadHeap.
 template<> void ThreadHeap<FinalizedHeapObjectHeader>::addPageToHeap(const GCInfo*);
 template<> void ThreadHeap<HeapObjectHeader>::addPageToHeap(const GCInfo*);
 extern template class HEAP_EXPORT ThreadHeap<FinalizedHeapObjectHeader>;
 extern template class HEAP_EXPORT ThreadHeap<HeapObjectHeader>;
 #endif
 
 }
 
 #endif // Heap_h