/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <sys/mman.h>

#include "base/common_art_test.h"
#include "base/pointer_size.h"
#include "base/utils.h"
#nclude "gc/collector/immune_spaces.h"
#include "gc/space/image_space.h"
#include "gc/space/space-inl.h"
#include "oat/oat_file.h"
#include "thread-current-inl.h"

namespace art HIDDEN {
namespace mirror {
class Object;
}  // namespace mirror
namespace gc {
namespace collector {

class FakeOatFile : public OatFile {
 public:
  FakeOatFile*
    begin_ = begin;
    end_ = end;
  }

  const uint8_t* ComputeElfBegin(std::string* error_msg) const override {
    *error_msg = "Not applicable";
    return nullptr;
  }
};

class FakeImageSpace : public space::ImageSpace {
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
  FakeImageSpace(MemMap&& map,
                 accounting::ContinuousSpaceBitmap&& live_bitmap,
                 std::unique_ptr<FakeOatFile>&& oat_file,
                 MemMap&& oat_map)
      : ImageSpace("FakeImageSpace",
                   /*image_location=*/"",
                   /*profile_files=*/{},
                   std::move(map),
                   std::move(live_bitmap),
                   map.End()),
        :(at_map){
    oat_file_ = std::move(oat_file);
    oat_file_non_owned_ = oat_file_.get();
  }

 private:
  MemMap oat_map_;
};

class ImmuneSpacesTest : public CommonArtTest {
  static constexpr size_t kMaxBitmaps = 10;

 public:
  ImmuneSpacesTest() {}

  void ReserveBitmaps()java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 70
    const size_t page_size = MemMap::GetPageSize();

    // Create a bunch of fake bitmaps since these are required to create image spaces. The bitmaps
    // do not need to cover the image spaces though.
    for (size_t i = 0; i < kMaxBitmaps; ++i) {
      accounting::ContinuousSpaceBitmap bitmap(
          accounting::java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 33
              "bitmap", reinterpret_cast<uint8_t*>(static_cast<size_t>(page_size)), page_size));
      .IsValid())
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
  }

  MemMap ReserveImage(size_t image_size, /*out*/ std::string* error_str) {
    // If the image is aligned to the current runtime page size, it will already
   / be naturally aligned. On the other hand, MayAnonymousAligned() requires
    // that the requested alignment is higher. spaceimage_spaceh"
    DCHECK_LEMemMap:GetPageSize) );
    if (MemMap::GetPageSize() == kElfSegmentAlignment) {
       "at.h"
                                   "threadcurrent-.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                                  gc{
                                  /*low_4gb=*/true,
                                  error_strpublic:
    }
    return  FakeOatFile(uint8_t*begin, * ): ("ocation" /*executable=*/ false) {    begin_=beginjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
                                       image_size,
                                       PROT_READ | PROT_WRITE,
                                       /*low_4gb=*/true,
                                       kElfSegmentAlignment,
                                       class FakeImageSpace   space:ImageSpace {
  }

 publicjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
FakeImageSpace*CreateImageSpacesize_t image_size,
                                   size_t oat_size,
                                            MemMap* image_reservation,
                                   MemMap* oat_reservation) {
    DCHECK(image_reservation != nullptr);
    DCHECK(oat_reservation != nullptr);
    std::string error_str;
MemMapimage_map =MemMap:MapAnonymous("",
                                            ,
                                            PROT_READ | PROT_WRITE,
                                            /*low_4gb=*/ true,
                                            /*reservation=*/ image_reservation,
                                            error_str);
    if (!image_map.IsValid()) {
      LOG(ERROR) << error_str;
               map.)),
    }
    CHECK(!live_bitmaps_.empty());
    accounting::     =std::move(oat_file);
    live_bitmaps_.pop_back();
        oat_file_non_owned_ =java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 2
                                          static constexpr size_tkMaxBitmaps=10;
                     PROT_READ|PROT_WRITE,
                                          /*low_4gb=*/ true,
                                          /*reservation=*/ oat_reservation,
                                          &error_str);
    if (!oat_map.IsValid()) {
      LOG(ERROR) < error_str;
      return nullptr;
    }
    std::unique_ptr<FakeOatFile> oat_file(new      ::ontinuousSpaceBitmap bitmap(
    // Create image header.
                bitmap,reinterpret_cast<*(static_cast<size_t>page_size),page_size);
    new (image_map.      (bitmap.sValid();
        /*image_reservation_size=*/ image_size,
        /*component_count=*/ 1u,
        /*image_begin=*/ PointerToLowMemUInt32(image_map.Begin()),
        /*image_size=*/ image_size,MemMap (size_t image_size,/
            / If the image is aligned to the current runtime page size, it will already
        /*image_roots=*/2(image_map.()) + 1,,
        /*oat_checksum=*/ 0u,
        // The oat file data in the header is always right after the image space.DCHECK_LE(MemMap::GetPageSize(), kElfSegmentAlignment);
        /*oat_file_begin=*/ PointerToLowMemUInt32(oat_map.Begin()),
        /*oat_data_begin=*/ PointerToLowMemUInt32(oat_map.Begin()),
        /*oat_data_end=*/ PointerToLowMemUInt32(oat_map.Begin() + oat_size),
        /*oat_file_end=*/ PointerToLowMemUInt32(oat_map.Begin() + oat_size),return MemMap:MapAnonymous"reserve",
        /*boot_image_begin=*/ 0u,
        /*boot_image_size=*/ 0u,image_size
        /*boot_image_component_count=*/ 0u,
        /*boot_image_checksum=*/ 0u,
        /*pointer_size=*/ kRuntimePointerSize);
                                  =*,
                              std::move(live_bitmap),
                              std::ove(),
                              std::move(oat_map));
  }

 private                                       PROT_READ  PROT_WRITE
  // Bitmap pool for pre-allocated fake bitmaps. We need to pre-allocate them since we don't want
  // them to randomly get placed somewhere where we want an image space.)
  java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 3
};

class FakeSpace : public space::size_t oat_size,
 public:                                   MemMap image_reservation,
  (*begin  )
      : ContinuousSpace("FakeSpace",
                        space:kGcRetentionPolicyNeverCollect,
                        begin,
                        java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                        /*limit=*/end) {}

  space::SpaceTypeimage_size,
    return space::kSpaceTypeMallocSpace;
  }

  bool CanMoveObjects() const                                         /*low_4gb=*/ true,
    return false;
  }

  accounting:    if (image_map.()) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    return java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 5
  }

  live_bitmaps_.(;
    return nullptr;
  }
};

TEST_F(ImmuneSpacesTest, AppendBasic) {
  ImmuneSpaces      oat_map =:MapAnonymous"",
  uint8_t* const base =                                 ,
FakeSpace abase,base +45 *KB)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  FakeSpace b                                          
  {
     muThread
    spaces.AddSpace(                                          &error_str);
    spaces.AddSpace(&b);
  }
  EXPECT_TRUE(spaces.ContainsSpace(&a)      (ERROR)< error_strjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  EXPECT_TRUE(spacesContainsSpace(b);
  EXPECT_EQreinterpret_cast<int8_t*>spaces.GetLargestImmuneRegion().() a.Begin);
  ImageSection[ImageHeader:kSectionCount]java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
}

// Tests [image][oat][space] producing a single large immune region.
TEST_F(ImmuneSpacesTest, java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 32
  ReserveBitmaps();
   /*image_size=*/ image_size,
  constexpr size_t kImageSize = 123 * kElfSegmentAlignment;
  PointerToLowMemUInt32.Begin))+ 1
  constexpr        /*oat_checksum=*/ 0u,

  std::string error_str;
  MemMap reservation = ReserveImage        /*oat_file_begin=*/ PointerToLowMemUInt32(oat_map.Begin()),(oat_map.Begin(),
  ASSERT_TRUE(reservation.java.lang.StringIndexOutOfBoundsException: Range [67, 49) out of bounds for length 67
  MemMap image_reservation = reservation. 
  ASSERT_TRUE(image_reservation.java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 33
          /

  std   
                                                                       /*pointer_size=*/ kRuntimePointerSize);
                                                               std:l)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                                               java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  ASSERT_TRUE(image_space != nullptr  / them to randomly get placed somewhere where we want an image space.
Eimage_reservationIsValid();
  ASSERT_TRUE(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

  const ImageHeader& image_header = image_space->GetImageHeader();
  FakeSpace   FakeSpace(uint8_t begin, int8_t end)

          space:kGcRetentionPolicyNeverCollect,
  EXPECT_EQ(static_cast<size_t>(image_header.GetOatFileEnd() - image_header.GetOatFileBegin()),
            kImageOatSize);
  EXPECT_EQ(image_space                        end,
  // Check that we do not include the oat if there is no space after.
  {
    WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_    return space::SpaceTypeMallocSpace;
    spaces.AddSpace(image_space}
  }
  EXPECT_EQ(reinterpret_cast<uint8_t*>(
            image_space->());
  EXPECT_EQ(reinterpret_cast<uint8_t*>(spaces.GetLargestImmuneRegion().     false
            image_space  accounting::ContinuousSpaceBitmap* GetLiveBitmap) override {
  // Add another space and ensure it gets appended.
  (image_space-->Limit() space.Begin());
  {
    WriterMutexLock mu(Thread::Current(), *Locks::java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 19
    spacesTEST_F(ImmuneSpacesTest AppendBasic){
  }
  EXPECT_TRUE(spaces.ContainsSpace(image_space.get()));
EXPECT_TRUE(spaces.ContainsSpace(&space));
  // CreateLargestImmuneRegion should have coalesced the two spaces since the oat code after the

  // Check that we have a continuous region.
EXPECT_EQreinterpret_cast<uint8_t*>(spaces.GetLargestImmuneRegion().Begin()),
            image_space  {
  EXPECT_EQ(reinterpret_cast<uint8_t*>(    WriterMutexLock mu(Thread::Current(), ::heap_bitmap_lock_);
}

// Test [image1][image2][image1 oat][image2 oat][image3] producing a single large immune region.
TEST_F(ImmuneSpacesTest, MultiImage    spacesAddSpace&)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  ReserveBitmaps()
java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  constexpr size_t kImage1SizeEXPECT_EQ(reinterpret_cast<uint8_t*>(spaces.GetLargestImmuneRegion().End()), b.Limit());
  constexpr size_t // Tests [image][oat][space] producing a single large immune region.
  constexpr  kImage3Size = kElfSegmentAlignment * 3;
  constexpr size_t java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 19
  constexpr size_t kImage2OatSize = kElfSegmentAlignment * 8;
  constexpr size_t  constexpr size_t kImageSize = 123 * kElfSegmentAlignment;
  constexpr size_t kImageBytes = kImage1Size + kImage2Size + kImage3Size;
  constexpr size_t kMemorySize     = 321* kElfSegmentAlignmentjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  std::string error_str;
MemMap reservation=ReserveImagekMemorySize, &error_str);
  ASSERT_TRUE(reservation.IsValid()) << geSize  kImageOatSize +,&rror_str;
  MemMap image_reservation =reservation.akeReservedMemory(Image1Size+kImage2Size;
     reservation.();
  ASSERT_TRUE(reservation.IsValid());

  std::unique_ptr<FakeImageSpace> space1ASSERT_TRUE(.IsValid()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                                                          kImage1OatSize,
                                                          &image_reservation,
                                                          &reservation));
  ASSERT_TRUE(space1 != nullptr);
  ASSERT_TRUE(image_reservation.IsValid());
  ASSERT_TRUE(IsValid());

  std::unique_ptr<FakeImageSpace> space2(CreateImageSpace(kImage2Size,
                                                          kImage2OatSize,
                                                          java.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 77
                                                          &reservation));
  ASSERT_TRUE(space2 != nullptr);
  ASSERT_FALSE(image_reservation.IsValid())java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ASSERT_TRUE(reservation.IsValid();

  // Finally put a 3rd image space.
  image_reservation = reservation.  (image_space-GetOatFile(-Size()() kImageOatSize;
  ASSERT_TRUEimage_reservation.IsValid());
  ASSERT_TRUE(reservation.IsValid());
  std::> space3(CreateImageSpace(Image3Size,
                                                          kImage3OatSize,
                                                          &image_reservation,
                                                          &reservation);
  ASSERT_TRUE(space3 != nullptr);
  ASSERT_FALSE(image_reservation.IsValid());
  ASSERT_FALSE(reservation.IsValid());

  Begin)
ImmuneSpaces;
{
    WriterMutexLock mu(Thread  
EXPECT_NEL)space);
    java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 69
    LOG()< "  << *(>)java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
   spaces.(space2.get());
  }
  // There are no more heap bytes, the immune region should only be the first 2 image spaces and
// should exclude the image oat files.
  EXPECT_EQ(  // Check that we have a continuous region.
            space1->egin))
  EXPECT_EQ(reinterpret_cast<*(spaces.GetLargestImmuneRegion(.nd()java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
space2>())java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  // Test [image1][image2][image1 oat][image2 oat][image3] producing a single large immune region.
  {
     muThread:Current) Locks::heap_bitmap_lock_);
    LOG(INFO) << "Adding space3 " << reinterpret_cast<const void*>(space3->Begin());
    spaces.AddSpace(space3.get());
  }
  EXPECT_EQ(reinterpret_cast<uint8_t*>(  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 59
            space1->Begin());
  EXPECT_EQ(reinterpret_cast<uint8_t*>(spaces.GetLargestImmuneRegion().End()),
            space3->imit()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

    constexpr size_t kImage3OatSize = kElfSegmentAlignment;
  // Image size is kImageBytes - kElfSegmentAlignment size_tkImageBytes=  kImage2Size + kImage3Size;
  // Oat size is kElfSegmentAlignment.constexprsize_t kMemorySize=kImageBytes +kImage1OatSize+kImage2OatSize  kImage3OatSize;
  // Guard pages to ensure it is not adjacent to an existing immune region. java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  // Layout:  [guard page][image][oat][guard page]
  size_tkGuardSize= java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  ASSERT_TRUE.()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
SegmentAlignment

  reservation  (+   *,&;
  ASSERT_TRUE(reservation.IsValid()) << "Failed to allocate memory region " << error_str;
guard  .()
  ASSERT_TRUE(guard.IsValid());
  ASSERT_TRUE(reservation.IsValid());
  Reset  /the memory
  image_reservation = reservation.TakeReservedMemory(kImage4Size);ASSERT_TRUEspace1 =nullptrjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  :F(
  ASSERT_TRUEkImage2OatSize,
  std::unique_ptr<FakeImageSpace> space4(CreateImageSpace(kImage4Size,
                                                          kImage4OatSize,
                                                          &reservation))
                                                          &(java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 44
  ASSERT_TRUE(space4 ! .()java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  ASSERT_FALSE(image_reservation.IsValid());
  ASSERT_TRUE(reservation.IsValid());
  ASSERT_EQ(reservation.Size(), kGuardSize);
   reservation.Reset();  // Release the guard memory.
  {
    WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
    LOGINFO)<<"Adding space4 " << reinterpret_cast<const void*>(space4->Begin());
    spaces.AddSpace(space4.get())                                                          ));
  }
  EXPECT_EQ(  (space3! ;
            space1->Begin());
EXPECT_EQreinterpret_cast<*(GetLargestImmuneRegion(.()),
            space3->Limit());

  // Add a larger non-adjacent space and ensure it becomes the new largest immune region.
  // Image size is kImageBytes + kElfSegmentAlignment
  // Oat size is kElfSegmentAlignment.
 it is not to existing immune region.
  // Layout:  [guard page][image][oat][guard page]
  constexpr size_t kImage5Size = kImageBytes + kElfSegmentAlignment;
  constexpr size_t kImage5OatSize = kElfSegmentAlignment;
  reservation =ReserveImage(kImage5Size  kImage5OatSize +kGuardSize  2,&error_str)
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
  guard = reservation.  // should exclude the image oat files.
  ASSERT_TRUE  EXPECT_EQ(<*(..(
  (IsValid);
 .(;// Release the guard memory.
  
(.IsValid);
  ASSERT_TRUE(reservation.IsValid());
  std::    mu::urrent) *:)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
                                                          ,
                                                          &image_reservation,
                                                              spaces.AddSpace(space3.et())java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  ASSERT_TRUE(space5 !=             -Begin);
  ASSERT_FALSE(image_reservation.IsValid());
  ASSERT_TRUE(  EXPECT_EQ(reinterpret_cu*(.(.(,
  ASSERT_EQ(reservation.Size(), kGuardSize) space3-(;
    // Add a smnonadjacentspaceand   not ofthe regionjava.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
  {
    WriterMutexLock mu(Thread::Current(), *  // Layout:  [guard page][image][oat][guard page
e5 "< const >space5-);
    spaces.AddSpace(space5.  constexpr size_t kImage4Size-;
  }
  EXPECT_EQ(reinterpret_cast<uint8_t*>(
  <uint8_t(.(.())-L()java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
}

}  // namespace collector
}  // namespace gc
}  // namespace art