Turn on -Wmissing-field-initializers on Linux.

test/unittests/compiler/change-lowering-unittest.cc

 // 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.
 
 #include "src/code-stubs.h"
 #include "src/compiler/change-lowering.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/simplified-operator.h"
@@ skipping 88 matching lines @@
 class ChangeLoweringCommonTest
     : public ChangeLoweringTest,
       public ::testing::WithParamInterface<MachineRepresentation> {
  public:
   ~ChangeLoweringCommonTest() override {}
 
   MachineRepresentation WordRepresentation() const final { return GetParam(); }
 };
 
 TARGET_TEST_P(ChangeLoweringCommonTest, StoreFieldSmi) {
-  FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
-                        Handle<Name>::null(), Type::Any(),
-                        MachineType::AnyTagged()};
+  FieldAccess access = {
+      kTaggedBase, FixedArrayBase::kHeaderSize, Handle<Name>::null(),
+      Type::Any(), MachineType::AnyTagged(),    kNoWriteBarrier};
   Node* p0 = Parameter(Type::TaggedPointer());
   Node* p1 = Parameter(Type::TaggedSigned());
   Node* store = graph()->NewNode(simplified()->StoreField(access), p0, p1,
                                  graph()->start(), graph()->start());
   Reduction r = Reduce(store);
 
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsStore(StoreRepresentation(MachineRepresentation::kTagged,
                                           kNoWriteBarrier),
                       p0, IsIntPtrConstant(access.offset - access.tag()), p1,
                       graph()->start(), graph()->start()));
 }
 
 
 TARGET_TEST_P(ChangeLoweringCommonTest, StoreFieldTagged) {
-  FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
-                        Handle<Name>::null(), Type::Any(),
-                        MachineType::AnyTagged()};
+  FieldAccess access = {
+      kTaggedBase, FixedArrayBase::kHeaderSize, Handle<Name>::null(),
+      Type::Any(), MachineType::AnyTagged(),    kFullWriteBarrier};
   Node* p0 = Parameter(Type::TaggedPointer());
   Node* p1 = Parameter(Type::Tagged());
   Node* store = graph()->NewNode(simplified()->StoreField(access), p0, p1,
                                  graph()->start(), graph()->start());
   Reduction r = Reduce(store);
 
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsStore(StoreRepresentation(MachineRepresentation::kTagged,
                                           kFullWriteBarrier),
                       p0, IsIntPtrConstant(access.offset - access.tag()), p1,
                       graph()->start(), graph()->start()));
 }
 
 
 TARGET_TEST_P(ChangeLoweringCommonTest, LoadField) {
-  FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
-                        Handle<Name>::null(), Type::Any(),
-                        MachineType::AnyTagged()};
+  FieldAccess access = {
+      kTaggedBase, FixedArrayBase::kHeaderSize, Handle<Name>::null(),
+      Type::Any(), MachineType::AnyTagged(),    kNoWriteBarrier};
   Node* p0 = Parameter(Type::TaggedPointer());
   Node* load = graph()->NewNode(simplified()->LoadField(access), p0,
                                 graph()->start(), graph()->start());
   Reduction r = Reduce(load);
 
   ASSERT_TRUE(r.Changed());
   Matcher<Node*> index_match = IsIntPtrConstant(access.offset - access.tag());
   EXPECT_THAT(r.replacement(),
               IsLoad(MachineType::AnyTagged(), p0,
                      IsIntPtrConstant(access.offset - access.tag()),
                      graph()->start(), graph()->start()));
 }
 
 
 TARGET_TEST_P(ChangeLoweringCommonTest, StoreElementTagged) {
   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
-                          MachineType::AnyTagged()};
+                          MachineType::AnyTagged(), kFullWriteBarrier};
   Node* p0 = Parameter(Type::TaggedPointer());
   Node* p1 = Parameter(Type::Signed32());
   Node* p2 = Parameter(Type::Tagged());
   Node* store = graph()->NewNode(simplified()->StoreElement(access), p0, p1, p2,
                                  graph()->start(), graph()->start());
   Reduction r = Reduce(store);
 
   const int element_size_shift =
       ElementSizeLog2Of(access.machine_type.representation());
   ASSERT_TRUE(r.Changed());
   Matcher<Node*> index_match =
       IsInt32Add(IsWord32Shl(p1, IsInt32Constant(element_size_shift)),
                  IsInt32Constant(access.header_size - access.tag()));
   if (!Is32()) {
     index_match = IsChangeUint32ToUint64(index_match);
   }
 
   EXPECT_THAT(r.replacement(),
               IsStore(StoreRepresentation(MachineRepresentation::kTagged,
                                           kFullWriteBarrier),
                       p0, index_match, p2, graph()->start(), graph()->start()));
 }
 
 
 TARGET_TEST_P(ChangeLoweringCommonTest, StoreElementUint8) {
   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
-                          Type::Signed32(), MachineType::Uint8()};
+                          Type::Signed32(), MachineType::Uint8(),
+                          kNoWriteBarrier};
   Node* p0 = Parameter(Type::TaggedPointer());
   Node* p1 = Parameter(Type::Signed32());
   Node* p2 = Parameter(Type::Signed32());
   Node* store = graph()->NewNode(simplified()->StoreElement(access), p0, p1, p2,
                                  graph()->start(), graph()->start());
   Reduction r = Reduce(store);
 
   ASSERT_TRUE(r.Changed());
   Matcher<Node*> index_match =
       IsInt32Add(p1, IsInt32Constant(access.header_size - access.tag()));
   if (!Is32()) {
     index_match = IsChangeUint32ToUint64(index_match);
   }
 
   EXPECT_THAT(r.replacement(),
               IsStore(StoreRepresentation(MachineRepresentation::kWord8,
                                           kNoWriteBarrier),
                       p0, index_match, p2, graph()->start(), graph()->start()));
 }
 
 
 TARGET_TEST_P(ChangeLoweringCommonTest, LoadElementTagged) {
   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
-                          MachineType::AnyTagged()};
+                          MachineType::AnyTagged(), kNoWriteBarrier};
   Node* p0 = Parameter(Type::TaggedPointer());
   Node* p1 = Parameter(Type::Signed32());
   Node* load = graph()->NewNode(simplified()->LoadElement(access), p0, p1,
                                 graph()->start(), graph()->start());
   Reduction r = Reduce(load);
 
   const int element_size_shift =
       ElementSizeLog2Of(access.machine_type.representation());
   ASSERT_TRUE(r.Changed());
   Matcher<Node*> index_match =
       IsInt32Add(IsWord32Shl(p1, IsInt32Constant(element_size_shift)),
                  IsInt32Constant(access.header_size - access.tag()));
   if (!Is32()) {
     index_match = IsChangeUint32ToUint64(index_match);
   }
 
   EXPECT_THAT(r.replacement(), IsLoad(MachineType::AnyTagged(), p0, index_match,
                                       graph()->start(), graph()->start()));
 }
 
 
 TARGET_TEST_P(ChangeLoweringCommonTest, LoadElementInt8) {
   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
-                          Type::Signed32(), MachineType::Int8()};
+                          Type::Signed32(), MachineType::Int8(),
+                          kNoWriteBarrier};
   Node* p0 = Parameter(Type::TaggedPointer());
   Node* p1 = Parameter(Type::Signed32());
   Node* load = graph()->NewNode(simplified()->LoadElement(access), p0, p1,
                                 graph()->start(), graph()->start());
   Reduction r = Reduce(load);
 
   ASSERT_TRUE(r.Changed());
   Matcher<Node*> index_match =
       IsInt32Add(p1, IsInt32Constant(access.header_size - access.tag()));
   if (!Is32()) {
@@ skipping 12 matching lines @@
   Reduction r = Reduce(alloc);
 
   // Only check that we lowered, but do not specify the exact form since
   // this is subject to change.
   ASSERT_TRUE(r.Changed());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8