Make unittests work in component build

src/compiler/common-operator.h

 // Copyright 2014 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_COMPILER_COMMON_OPERATOR_H_
 #define V8_COMPILER_COMMON_OPERATOR_H_
 
 #include "src/assembler.h"
+#include "src/base/compiler-specific.h"
 #include "src/compiler/frame-states.h"
 #include "src/deoptimize-reason.h"
+#include "src/globals.h"
 #include "src/machine-type.h"
 #include "src/zone/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // Forward declarations.
 class CallDescriptor;
 struct CommonOperatorGlobalCache;
@@ skipping 11 matching lines @@
       return BranchHint::kFalse;
     case BranchHint::kFalse:
       return BranchHint::kTrue;
   }
   UNREACHABLE();
   return hint;
 }
 
 inline size_t hash_value(BranchHint hint) { return static_cast<size_t>(hint); }
 
-std::ostream& operator<<(std::ostream&, BranchHint);
+V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, BranchHint);
 
-BranchHint BranchHintOf(const Operator* const);
+V8_EXPORT_PRIVATE BranchHint BranchHintOf(const Operator* const);
 
 // Deoptimize reason for Deoptimize, DeoptimizeIf and DeoptimizeUnless.
 DeoptimizeReason DeoptimizeReasonOf(Operator const* const);
 
 // Deoptimize bailout kind.
 enum class DeoptimizeKind : uint8_t { kEager, kSoft };
 
 size_t hash_value(DeoptimizeKind kind);
 
 std::ostream& operator<<(std::ostream&, DeoptimizeKind);
@@ skipping 36 matching lines @@
   const BranchHint hint_;
 };
 
 bool operator==(SelectParameters const&, SelectParameters const&);
 bool operator!=(SelectParameters const&, SelectParameters const&);
 
 size_t hash_value(SelectParameters const& p);
 
 std::ostream& operator<<(std::ostream&, SelectParameters const& p);
 
-SelectParameters const& SelectParametersOf(const Operator* const);
+V8_EXPORT_PRIVATE SelectParameters const& SelectParametersOf(
+    const Operator* const);
 
-CallDescriptor const* CallDescriptorOf(const Operator* const);
+V8_EXPORT_PRIVATE CallDescriptor const* CallDescriptorOf(const Operator* const);
 
-size_t ProjectionIndexOf(const Operator* const);
+V8_EXPORT_PRIVATE size_t ProjectionIndexOf(const Operator* const);
 
-MachineRepresentation PhiRepresentationOf(const Operator* const);
-
+V8_EXPORT_PRIVATE MachineRepresentation
+PhiRepresentationOf(const Operator* const);
 
 // The {IrOpcode::kParameter} opcode represents an incoming parameter to the
 // function. This class bundles the index and a debug name for such operators.
 class ParameterInfo final {
  public:
   ParameterInfo(int index, const char* debug_name)
       : index_(index), debug_name_(debug_name) {}
 
   int index() const { return index_; }
   const char* debug_name() const { return debug_name_; }
 
  private:
   int index_;
   const char* debug_name_;
 };
 
 std::ostream& operator<<(std::ostream&, ParameterInfo const&);
 
-int ParameterIndexOf(const Operator* const);
+V8_EXPORT_PRIVATE int ParameterIndexOf(const Operator* const);
 const ParameterInfo& ParameterInfoOf(const Operator* const);
 
 class RelocatablePtrConstantInfo final {
  public:
   enum Type { kInt32, kInt64 };
 
   RelocatablePtrConstantInfo(int32_t value, RelocInfo::Mode rmode)
       : value_(value), rmode_(rmode), type_(kInt32) {}
   RelocatablePtrConstantInfo(int64_t value, RelocInfo::Mode rmode)
       : value_(value), rmode_(rmode), type_(kInt64) {}
@@ skipping 35 matching lines @@
 
 int OsrValueIndexOf(Operator const*);
 
 enum class OsrGuardType { kUninitialized, kSignedSmall, kAny };
 size_t hash_value(OsrGuardType type);
 std::ostream& operator<<(std::ostream&, OsrGuardType);
 OsrGuardType OsrGuardTypeOf(Operator const*);
 
 // Interface for building common operators that can be used at any level of IR,
 // including JavaScript, mid-level, and low-level.
-class CommonOperatorBuilder final : public ZoneObject {
+class V8_EXPORT_PRIVATE CommonOperatorBuilder final
+    : public NON_EXPORTED_BASE(ZoneObject) {
  public:
   explicit CommonOperatorBuilder(Zone* zone);
 
   const Operator* Dead();
   const Operator* End(size_t control_input_count);
   const Operator* Branch(BranchHint = BranchHint::kNone);
   const Operator* IfTrue();
   const Operator* IfFalse();
   const Operator* IfSuccess();
   const Operator* IfException();
@@ skipping 69 matching lines @@
   Zone* const zone_;
 
   DISALLOW_COPY_AND_ASSIGN(CommonOperatorBuilder);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_COMMON_OPERATOR_H_