diff options
author | Ian Rogers <irogers@google.com> | 2014-10-08 12:43:28 -0700 |
---|---|---|
committer | Ian Rogers <irogers@google.com> | 2014-10-09 16:05:58 -0700 |
commit | 13735955f39b3b304c37d2b2840663c131262c18 (patch) | |
tree | 0a731ac42b8230f9929172fa3e3d8051874e2b18 /compiler | |
parent | 25b18bbdaa36ff936eb44f228f0518d4223e9d52 (diff) | |
download | android_art-13735955f39b3b304c37d2b2840663c131262c18.tar.gz android_art-13735955f39b3b304c37d2b2840663c131262c18.tar.bz2 android_art-13735955f39b3b304c37d2b2840663c131262c18.zip |
stdint types all the way!
Change-Id: I4e4ef3a2002fc59ebd9097087f150eaf3f2a7e08
Diffstat (limited to 'compiler')
-rw-r--r-- | compiler/common_compiler_test.cc | 10 | ||||
-rw-r--r-- | compiler/dex/mir_graph.cc | 2 | ||||
-rw-r--r-- | compiler/driver/compiler_driver.cc | 6 | ||||
-rw-r--r-- | compiler/image_test.cc | 12 | ||||
-rw-r--r-- | compiler/image_writer.cc | 26 | ||||
-rw-r--r-- | compiler/image_writer.h | 16 | ||||
-rw-r--r-- | compiler/oat_test.cc | 2 | ||||
-rw-r--r-- | compiler/oat_writer.cc | 2 | ||||
-rw-r--r-- | compiler/optimizing/locations.h | 22 | ||||
-rw-r--r-- | compiler/utils/arm/assembler_arm.cc | 2 | ||||
-rw-r--r-- | compiler/utils/arm/assembler_arm.h | 2 | ||||
-rw-r--r-- | compiler/utils/arm/assembler_arm32.h | 2 | ||||
-rw-r--r-- | compiler/utils/arm/assembler_thumb2.h | 2 | ||||
-rw-r--r-- | compiler/utils/arm/constants_arm.h | 4 | ||||
-rw-r--r-- | compiler/utils/arm64/assembler_arm64.h | 2 | ||||
-rw-r--r-- | compiler/utils/assembler.cc | 6 | ||||
-rw-r--r-- | compiler/utils/assembler.h | 28 | ||||
-rw-r--r-- | compiler/utils/x86/assembler_x86.cc | 8 | ||||
-rw-r--r-- | compiler/utils/x86/assembler_x86.h | 6 | ||||
-rw-r--r-- | compiler/utils/x86_64/assembler_x86_64.cc | 8 | ||||
-rw-r--r-- | compiler/utils/x86_64/assembler_x86_64.h | 2 |
21 files changed, 85 insertions, 85 deletions
diff --git a/compiler/common_compiler_test.cc b/compiler/common_compiler_test.cc index fbaed9ffab..e3eb9e9915 100644 --- a/compiler/common_compiler_test.cc +++ b/compiler/common_compiler_test.cc @@ -144,12 +144,12 @@ CommonCompilerTest::~CommonCompilerTest() {} OatFile::OatMethod CommonCompilerTest::CreateOatMethod(const void* code, const uint8_t* gc_map) { CHECK(code != nullptr); - const byte* base; + const uint8_t* base; uint32_t code_offset, gc_map_offset; if (gc_map == nullptr) { - base = reinterpret_cast<const byte*>(code); // Base of data points at code. - base -= kPointerSize; // Move backward so that code_offset != 0. - code_offset = kPointerSize; + base = reinterpret_cast<const uint8_t*>(code); // Base of data points at code. + base -= sizeof(void*); // Move backward so that code_offset != 0. + code_offset = sizeof(void*); gc_map_offset = 0; } else { // TODO: 64bit support. @@ -398,7 +398,7 @@ void CommonCompilerTest::ReserveImageSpace() { // accidentally end up colliding with the fixed memory address when we need to load the image. std::string error_msg; image_reservation_.reset(MemMap::MapAnonymous("image reservation", - reinterpret_cast<byte*>(ART_BASE_ADDRESS), + reinterpret_cast<uint8_t*>(ART_BASE_ADDRESS), (size_t)100 * 1024 * 1024, // 100MB PROT_NONE, false /* no need for 4gb flag with fixed mmap*/, diff --git a/compiler/dex/mir_graph.cc b/compiler/dex/mir_graph.cc index 7e83c0c6bc..7dfdc760bd 100644 --- a/compiler/dex/mir_graph.cc +++ b/compiler/dex/mir_graph.cc @@ -352,7 +352,7 @@ void MIRGraph::ProcessTryCatchBlocks() { } // Iterate over each of the handlers to enqueue the empty Catch blocks. - const byte* handlers_ptr = DexFile::GetCatchHandlerData(*current_code_item_, 0); + const uint8_t* handlers_ptr = DexFile::GetCatchHandlerData(*current_code_item_, 0); uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr); for (uint32_t idx = 0; idx < handlers_size; idx++) { CatchHandlerIterator iterator(handlers_ptr); diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc index cdb816d560..fb648fc532 100644 --- a/compiler/driver/compiler_driver.cc +++ b/compiler/driver/compiler_driver.cc @@ -627,7 +627,7 @@ static void ResolveExceptionsForMethod(MutableMethodHelper* mh, if (code_item->tries_size_ == 0) { return; // nothing to process } - const byte* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0); + const uint8_t* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0); size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list); for (size_t i = 0; i < num_encoded_catch_handlers; i++) { int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list); @@ -1505,7 +1505,7 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag // Note the class_data pointer advances through the headers, // static fields, instance fields, direct methods, and virtual // methods. - const byte* class_data = dex_file.GetClassData(class_def); + const uint8_t* class_data = dex_file.GetClassData(class_def); if (class_data == nullptr) { // Empty class such as a marker interface. requires_constructor_barrier = false; @@ -1882,7 +1882,7 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz if (manager->GetCompiler()->verification_results_->IsClassRejected(ref)) { return; } - const byte* class_data = dex_file.GetClassData(class_def); + const uint8_t* class_data = dex_file.GetClassData(class_def); if (class_data == nullptr) { // empty class, probably a marker interface return; diff --git a/compiler/image_test.cc b/compiler/image_test.cc index 5834e8e940..cf4259f790 100644 --- a/compiler/image_test.cc +++ b/compiler/image_test.cc @@ -163,8 +163,8 @@ TEST_F(ImageTest, WriteRead) { gc::space::ImageSpace* image_space = heap->GetImageSpace(); image_space->VerifyImageAllocations(); - byte* image_begin = image_space->Begin(); - byte* image_end = image_space->End(); + uint8_t* image_begin = image_space->Begin(); + uint8_t* image_end = image_space->End(); CHECK_EQ(requested_image_base, reinterpret_cast<uintptr_t>(image_begin)); for (size_t i = 0; i < dex->NumClassDefs(); ++i) { const DexFile::ClassDef& class_def = dex->GetClassDef(i); @@ -173,11 +173,11 @@ TEST_F(ImageTest, WriteRead) { EXPECT_TRUE(klass != nullptr) << descriptor; if (image_classes.find(descriptor) != image_classes.end()) { // Image classes should be located inside the image. - EXPECT_LT(image_begin, reinterpret_cast<byte*>(klass)) << descriptor; - EXPECT_LT(reinterpret_cast<byte*>(klass), image_end) << descriptor; + EXPECT_LT(image_begin, reinterpret_cast<uint8_t*>(klass)) << descriptor; + EXPECT_LT(reinterpret_cast<uint8_t*>(klass), image_end) << descriptor; } else { - EXPECT_TRUE(reinterpret_cast<byte*>(klass) >= image_end || - reinterpret_cast<byte*>(klass) < image_begin) << descriptor; + EXPECT_TRUE(reinterpret_cast<uint8_t*>(klass) >= image_end || + reinterpret_cast<uint8_t*>(klass) < image_begin) << descriptor; } EXPECT_TRUE(Monitor::IsValidLockWord(klass->GetLockWord(false))); } diff --git a/compiler/image_writer.cc b/compiler/image_writer.cc index 6fff5f4503..35a3d4b3b2 100644 --- a/compiler/image_writer.cc +++ b/compiler/image_writer.cc @@ -559,10 +559,10 @@ void ImageWriter::CalculateNewObjectOffsets() { void ImageWriter::CreateHeader(size_t oat_loaded_size, size_t oat_data_offset) { CHECK_NE(0U, oat_loaded_size); - const byte* oat_file_begin = GetOatFileBegin(); - const byte* oat_file_end = oat_file_begin + oat_loaded_size; + const uint8_t* oat_file_begin = GetOatFileBegin(); + const uint8_t* oat_file_end = oat_file_begin + oat_loaded_size; oat_data_begin_ = oat_file_begin + oat_data_offset; - const byte* oat_data_end = oat_data_begin_ + oat_file_->Size(); + const uint8_t* oat_data_end = oat_data_begin_ + oat_file_->Size(); // Return to write header at start of image with future location of image_roots. At this point, // image_end_ is the size of the image (excluding bitmaps). @@ -604,8 +604,8 @@ void ImageWriter::CopyAndFixupObjectsCallback(Object* obj, void* arg) { ImageWriter* image_writer = reinterpret_cast<ImageWriter*>(arg); // see GetLocalAddress for similar computation size_t offset = image_writer->GetImageOffset(obj); - byte* dst = image_writer->image_->Begin() + offset; - const byte* src = reinterpret_cast<const byte*>(obj); + uint8_t* dst = image_writer->image_->Begin() + offset; + const uint8_t* src = reinterpret_cast<const uint8_t*>(obj); size_t n = obj->SizeOf(); DCHECK_LT(offset + n, image_writer->image_->Size()); memcpy(dst, src, n); @@ -688,7 +688,7 @@ void ImageWriter::FixupObject(Object* orig, Object* copy) { } } -const byte* ImageWriter::GetQuickCode(mirror::ArtMethod* method, bool* quick_is_interpreted) { +const uint8_t* ImageWriter::GetQuickCode(mirror::ArtMethod* method, bool* quick_is_interpreted) { DCHECK(!method->IsResolutionMethod() && !method->IsImtConflictMethod() && !method->IsAbstract()) << PrettyMethod(method); @@ -696,7 +696,7 @@ const byte* ImageWriter::GetQuickCode(mirror::ArtMethod* method, bool* quick_is_ // trampoline. // Quick entrypoint: - const byte* quick_code = GetOatAddress(method->GetQuickOatCodeOffset()); + const uint8_t* quick_code = GetOatAddress(method->GetQuickOatCodeOffset()); *quick_is_interpreted = false; if (quick_code != nullptr && (!method->IsStatic() || method->IsConstructor() || method->GetDeclaringClass()->IsInitialized())) { @@ -718,7 +718,7 @@ const byte* ImageWriter::GetQuickCode(mirror::ArtMethod* method, bool* quick_is_ return quick_code; } -const byte* ImageWriter::GetQuickEntryPoint(mirror::ArtMethod* method) { +const uint8_t* ImageWriter::GetQuickEntryPoint(mirror::ArtMethod* method) { // Calculate the quick entry point following the same logic as FixupMethod() below. // The resolution method has a special trampoline to call. if (UNLIKELY(method == Runtime::Current()->GetResolutionMethod())) { @@ -757,14 +757,14 @@ void ImageWriter::FixupMethod(ArtMethod* orig, ArtMethod* copy) { copy->SetEntryPointFromPortableCompiledCode<kVerifyNone>(GetOatAddress(portable_to_interpreter_bridge_offset_)); copy->SetEntryPointFromQuickCompiledCode<kVerifyNone>(GetOatAddress(quick_to_interpreter_bridge_offset_)); copy->SetEntryPointFromInterpreter<kVerifyNone>(reinterpret_cast<EntryPointFromInterpreter*> - (const_cast<byte*>(GetOatAddress(interpreter_to_interpreter_bridge_offset_)))); + (const_cast<uint8_t*>(GetOatAddress(interpreter_to_interpreter_bridge_offset_)))); } else { bool quick_is_interpreted; - const byte* quick_code = GetQuickCode(orig, &quick_is_interpreted); + const uint8_t* quick_code = GetQuickCode(orig, &quick_is_interpreted); copy->SetEntryPointFromQuickCompiledCode<kVerifyNone>(quick_code); // Portable entrypoint: - const byte* portable_code = GetOatAddress(orig->GetPortableOatCodeOffset()); + const uint8_t* portable_code = GetOatAddress(orig->GetPortableOatCodeOffset()); bool portable_is_interpreted = false; if (portable_code != nullptr && (!orig->IsStatic() || orig->IsConstructor() || orig->GetDeclaringClass()->IsInitialized())) { @@ -794,7 +794,7 @@ void ImageWriter::FixupMethod(ArtMethod* orig, ArtMethod* copy) { } else { // Normal (non-abstract non-native) methods have various tables to relocate. uint32_t native_gc_map_offset = orig->GetOatNativeGcMapOffset(); - const byte* native_gc_map = GetOatAddress(native_gc_map_offset); + const uint8_t* native_gc_map = GetOatAddress(native_gc_map_offset); copy->SetNativeGcMap<kVerifyNone>(reinterpret_cast<const uint8_t*>(native_gc_map)); } @@ -805,7 +805,7 @@ void ImageWriter::FixupMethod(ArtMethod* orig, ArtMethod* copy) { : interpreter_to_compiled_code_bridge_offset_; copy->SetEntryPointFromInterpreter<kVerifyNone>( reinterpret_cast<EntryPointFromInterpreter*>( - const_cast<byte*>(GetOatAddress(interpreter_code)))); + const_cast<uint8_t*>(GetOatAddress(interpreter_code)))); } } } diff --git a/compiler/image_writer.h b/compiler/image_writer.h index bdf06148ec..e6a98d1143 100644 --- a/compiler/image_writer.h +++ b/compiler/image_writer.h @@ -38,7 +38,7 @@ namespace art { class ImageWriter { public: ImageWriter(const CompilerDriver& compiler_driver, uintptr_t image_begin) - : compiler_driver_(compiler_driver), image_begin_(reinterpret_cast<byte*>(image_begin)), + : compiler_driver_(compiler_driver), image_begin_(reinterpret_cast<uint8_t*>(image_begin)), image_end_(0), image_roots_address_(0), oat_file_(NULL), oat_data_begin_(NULL), interpreter_to_interpreter_bridge_offset_(0), interpreter_to_compiled_code_bridge_offset_(0), jni_dlsym_lookup_offset_(0), @@ -65,7 +65,7 @@ class ImageWriter { return reinterpret_cast<mirror::Object*>(image_begin_ + GetImageOffset(object)); } - byte* GetOatFileBegin() const { + uint8_t* GetOatFileBegin() const { return image_begin_ + RoundUp(image_end_, kPageSize); } @@ -100,11 +100,11 @@ class ImageWriter { mirror::Object* GetLocalAddress(mirror::Object* object) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { size_t offset = GetImageOffset(object); - byte* dst = image_->Begin() + offset; + uint8_t* dst = image_->Begin() + offset; return reinterpret_cast<mirror::Object*>(dst); } - const byte* GetOatAddress(uint32_t offset) const { + const uint8_t* GetOatAddress(uint32_t offset) const { #if !defined(ART_USE_PORTABLE_COMPILER) // With Quick, code is within the OatFile, as there are all in one // .o ELF object. However with Portable, the code is always in @@ -171,10 +171,10 @@ class ImageWriter { SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Get quick code for non-resolution/imt_conflict/abstract method. - const byte* GetQuickCode(mirror::ArtMethod* method, bool* quick_is_interpreted) + const uint8_t* GetQuickCode(mirror::ArtMethod* method, bool* quick_is_interpreted) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - const byte* GetQuickEntryPoint(mirror::ArtMethod* method) + const uint8_t* GetQuickEntryPoint(mirror::ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Patches references in OatFile to expect runtime addresses. @@ -183,7 +183,7 @@ class ImageWriter { const CompilerDriver& compiler_driver_; // Beginning target image address for the output image. - byte* image_begin_; + uint8_t* image_begin_; // Offset to the free space in image_. size_t image_end_; @@ -201,7 +201,7 @@ class ImageWriter { std::vector<std::pair<mirror::Object*, uint32_t>> saved_hashes_; // Beginning target oat address for the pointers from the output image to its oat file. - const byte* oat_data_begin_; + const uint8_t* oat_data_begin_; // Image bitmap which lets us know where the objects inside of the image reside. std::unique_ptr<gc::accounting::ContinuousSpaceBitmap> image_bitmap_; diff --git a/compiler/oat_test.cc b/compiler/oat_test.cc index 0b1f9e2cf9..3fcc369c5e 100644 --- a/compiler/oat_test.cc +++ b/compiler/oat_test.cc @@ -155,7 +155,7 @@ TEST_F(OatTest, WriteRead) { ScopedObjectAccess soa(Thread::Current()); for (size_t i = 0; i < dex_file->NumClassDefs(); i++) { const DexFile::ClassDef& class_def = dex_file->GetClassDef(i); - const byte* class_data = dex_file->GetClassData(class_def); + const uint8_t* class_data = dex_file->GetClassData(class_def); size_t num_virtual_methods = 0; if (class_data != NULL) { ClassDataItemIterator it(*dex_file, class_data); diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc index e64d2ab279..be52f40a0b 100644 --- a/compiler/oat_writer.cc +++ b/compiler/oat_writer.cc @@ -1208,7 +1208,7 @@ bool OatWriter::VisitDexMethods(DexMethodVisitor* visitor) { return false; } const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index); - const byte* class_data = dex_file->GetClassData(class_def); + const uint8_t* class_data = dex_file->GetClassData(class_def); if (class_data != NULL) { // ie not an empty class, such as a marker interface ClassDataItemIterator it(*dex_file, class_data); while (it.HasNextStaticField()) { diff --git a/compiler/optimizing/locations.h b/compiler/optimizing/locations.h index 24d7ad3c57..dcf70f27b0 100644 --- a/compiler/optimizing/locations.h +++ b/compiler/optimizing/locations.h @@ -95,7 +95,7 @@ class Location : public ValueObject { static Location ConstantLocation(HConstant* constant) { DCHECK(constant != nullptr); - return Location(kConstant | reinterpret_cast<uword>(constant)); + return Location(kConstant | reinterpret_cast<uintptr_t>(constant)); } HConstant* GetConstant() const { @@ -170,7 +170,7 @@ class Location : public ValueObject { } static Location StackSlot(intptr_t stack_index) { - uword payload = EncodeStackIndex(stack_index); + uintptr_t payload = EncodeStackIndex(stack_index); Location loc(kStackSlot, payload); // Ensure that sign is preserved. DCHECK_EQ(loc.GetStackIndex(), stack_index); @@ -182,7 +182,7 @@ class Location : public ValueObject { } static Location DoubleStackSlot(intptr_t stack_index) { - uword payload = EncodeStackIndex(stack_index); + uintptr_t payload = EncodeStackIndex(stack_index); Location loc(kDoubleStackSlot, payload); // Ensure that sign is preserved. DCHECK_EQ(loc.GetStackIndex(), stack_index); @@ -288,27 +288,27 @@ class Location : public ValueObject { return PolicyField::Decode(GetPayload()); } - uword GetEncoding() const { + uintptr_t GetEncoding() const { return GetPayload(); } private: // Number of bits required to encode Kind value. static constexpr uint32_t kBitsForKind = 4; - static constexpr uint32_t kBitsForPayload = kWordSize * kBitsPerByte - kBitsForKind; - static constexpr uword kLocationConstantMask = 0x3; + static constexpr uint32_t kBitsForPayload = kBitsPerIntPtrT - kBitsForKind; + static constexpr uintptr_t kLocationConstantMask = 0x3; - explicit Location(uword value) : value_(value) {} + explicit Location(uintptr_t value) : value_(value) {} - Location(Kind kind, uword payload) + Location(Kind kind, uintptr_t payload) : value_(KindField::Encode(kind) | PayloadField::Encode(payload)) {} - uword GetPayload() const { + uintptr_t GetPayload() const { return PayloadField::Decode(value_); } typedef BitField<Kind, 0, kBitsForKind> KindField; - typedef BitField<uword, kBitsForKind, kBitsForPayload> PayloadField; + typedef BitField<uintptr_t, kBitsForKind, kBitsForPayload> PayloadField; // Layout for kUnallocated locations payload. typedef BitField<Policy, 0, 3> PolicyField; @@ -320,7 +320,7 @@ class Location : public ValueObject { // Location either contains kind and payload fields or a tagged handle for // a constant locations. Values of enumeration Kind are selected in such a // way that none of them can be interpreted as a kConstant tag. - uword value_; + uintptr_t value_; }; class RegisterSet : public ValueObject { diff --git a/compiler/utils/arm/assembler_arm.cc b/compiler/utils/arm/assembler_arm.cc index 637a1ff297..b430c7ee97 100644 --- a/compiler/utils/arm/assembler_arm.cc +++ b/compiler/utils/arm/assembler_arm.cc @@ -386,7 +386,7 @@ bool Address::CanHoldStoreOffsetThumb(StoreOperandType type, int offset) { void ArmAssembler::Pad(uint32_t bytes) { AssemblerBuffer::EnsureCapacity ensured(&buffer_); for (uint32_t i = 0; i < bytes; ++i) { - buffer_.Emit<byte>(0); + buffer_.Emit<uint8_t>(0); } } diff --git a/compiler/utils/arm/assembler_arm.h b/compiler/utils/arm/assembler_arm.h index 54965f678f..14d48b7737 100644 --- a/compiler/utils/arm/assembler_arm.h +++ b/compiler/utils/arm/assembler_arm.h @@ -600,7 +600,7 @@ class ArmAssembler : public Assembler { virtual void Ror(Register rd, Register rm, Register rn, bool setcc = false, Condition cond = AL) = 0; - static bool IsInstructionForExceptionHandling(uword pc); + static bool IsInstructionForExceptionHandling(uintptr_t pc); virtual void Bind(Label* label) = 0; diff --git a/compiler/utils/arm/assembler_arm32.h b/compiler/utils/arm/assembler_arm32.h index 7f9094d664..c89fd04e9e 100644 --- a/compiler/utils/arm/assembler_arm32.h +++ b/compiler/utils/arm/assembler_arm32.h @@ -273,7 +273,7 @@ class Arm32Assembler FINAL : public ArmAssembler { Condition cond = AL) OVERRIDE; - static bool IsInstructionForExceptionHandling(uword pc); + static bool IsInstructionForExceptionHandling(uintptr_t pc); // Emit data (e.g. encoded instruction or immediate) to the // instruction stream. diff --git a/compiler/utils/arm/assembler_thumb2.h b/compiler/utils/arm/assembler_thumb2.h index ee33bf23c9..9e7d394555 100644 --- a/compiler/utils/arm/assembler_thumb2.h +++ b/compiler/utils/arm/assembler_thumb2.h @@ -303,7 +303,7 @@ class Thumb2Assembler FINAL : public ArmAssembler { Condition cond = AL) OVERRIDE; - static bool IsInstructionForExceptionHandling(uword pc); + static bool IsInstructionForExceptionHandling(uintptr_t pc); // Emit data (e.g. encoded instruction or immediate) to the. // instruction stream. diff --git a/compiler/utils/arm/constants_arm.h b/compiler/utils/arm/constants_arm.h index 3e4cd43dc3..092c89192d 100644 --- a/compiler/utils/arm/constants_arm.h +++ b/compiler/utils/arm/constants_arm.h @@ -223,7 +223,7 @@ typedef uint16_t RegList; // Example: Test whether the instruction at ptr does set the condition code // bits. // -// bool InstructionSetsConditionCodes(byte* ptr) { +// bool InstructionSetsConditionCodes(uint8_t* ptr) { // Instr* instr = Instr::At(ptr); // int type = instr->TypeField(); // return ((type == 0) || (type == 1)) && instr->HasS(); @@ -435,7 +435,7 @@ class Instr { // reference to an instruction is to convert a pointer. There is no way // to allocate or create instances of class Instr. // Use the At(pc) function to create references to Instr. - static Instr* At(uword pc) { return reinterpret_cast<Instr*>(pc); } + static Instr* At(uintptr_t pc) { return reinterpret_cast<Instr*>(pc); } Instr* Next() { return this + kInstrSize; } private: diff --git a/compiler/utils/arm64/assembler_arm64.h b/compiler/utils/arm64/assembler_arm64.h index 373fd34314..ef833345f7 100644 --- a/compiler/utils/arm64/assembler_arm64.h +++ b/compiler/utils/arm64/assembler_arm64.h @@ -214,7 +214,7 @@ class Arm64Assembler FINAL : public Assembler { void AddConstant(Register rd, Register rn, int32_t value, vixl::Condition cond = vixl::al); // Vixl assembler. - vixl::MacroAssembler* vixl_masm_; + vixl::MacroAssembler* const vixl_masm_; // List of exception blocks to generate at the end of the code cache. std::vector<Arm64Exception*> exception_blocks_; diff --git a/compiler/utils/assembler.cc b/compiler/utils/assembler.cc index e3045e1a7b..8a1289dc17 100644 --- a/compiler/utils/assembler.cc +++ b/compiler/utils/assembler.cc @@ -30,8 +30,8 @@ namespace art { -static byte* NewContents(size_t capacity) { - return new byte[capacity]; +static uint8_t* NewContents(size_t capacity) { + return new uint8_t[capacity]; } @@ -85,7 +85,7 @@ void AssemblerBuffer::ExtendCapacity() { size_t new_capacity = std::min(old_capacity * 2, old_capacity + 1 * MB); // Allocate the new data area and copy contents of the old one to it. - byte* new_contents = NewContents(new_capacity); + uint8_t* new_contents = NewContents(new_capacity); memmove(reinterpret_cast<void*>(new_contents), reinterpret_cast<void*>(contents_), old_size); diff --git a/compiler/utils/assembler.h b/compiler/utils/assembler.h index 4addfa0946..91b8d8ab9a 100644 --- a/compiler/utils/assembler.h +++ b/compiler/utils/assembler.h @@ -56,19 +56,19 @@ namespace x86_64 { class ExternalLabel { public: - ExternalLabel(const char* name, uword address) + ExternalLabel(const char* name, uintptr_t address) : name_(name), address_(address) { DCHECK(name != nullptr); } const char* name() const { return name_; } - uword address() const { + uintptr_t address() const { return address_; } private: const char* name_; - const uword address_; + const uintptr_t address_; }; class Label { @@ -84,12 +84,12 @@ class Label { // for unused labels. int Position() const { CHECK(!IsUnused()); - return IsBound() ? -position_ - kPointerSize : position_ - kPointerSize; + return IsBound() ? -position_ - sizeof(void*) : position_ - sizeof(void*); } int LinkPosition() const { CHECK(IsLinked()); - return position_ - kPointerSize; + return position_ - sizeof(void*); } bool IsBound() const { return position_ < 0; } @@ -105,13 +105,13 @@ class Label { void BindTo(int position) { CHECK(!IsBound()); - position_ = -position - kPointerSize; + position_ = -position - sizeof(void*); CHECK(IsBound()); } void LinkTo(int position) { CHECK(!IsBound()); - position_ = position + kPointerSize; + position_ = position + sizeof(void*); CHECK(IsLinked()); } @@ -236,7 +236,7 @@ class AssemblerBuffer { return cursor_ - contents_; } - byte* contents() const { return contents_; } + uint8_t* contents() const { return contents_; } // Copy the assembled instructions into the specified memory block // and apply all fixups. @@ -316,9 +316,9 @@ class AssemblerBuffer { // for a single, fast space check per instruction. static const int kMinimumGap = 32; - byte* contents_; - byte* cursor_; - byte* limit_; + uint8_t* contents_; + uint8_t* cursor_; + uint8_t* limit_; AssemblerFixup* fixup_; #ifndef NDEBUG bool fixups_processed_; @@ -327,8 +327,8 @@ class AssemblerBuffer { // Head of linked list of slow paths SlowPath* slow_path_; - byte* cursor() const { return cursor_; } - byte* limit() const { return limit_; } + uint8_t* cursor() const { return cursor_; } + uint8_t* limit() const { return limit_; } size_t Capacity() const { CHECK_GE(limit_, contents_); return (limit_ - contents_) + kMinimumGap; @@ -340,7 +340,7 @@ class AssemblerBuffer { // Compute the limit based on the data area and the capacity. See // description of kMinimumGap for the reasoning behind the value. - static byte* ComputeLimit(byte* data, size_t capacity) { + static uint8_t* ComputeLimit(uint8_t* data, size_t capacity) { return data + capacity - kMinimumGap; } diff --git a/compiler/utils/x86/assembler_x86.cc b/compiler/utils/x86/assembler_x86.cc index 3ff24b7a27..4ddf9793fd 100644 --- a/compiler/utils/x86/assembler_x86.cc +++ b/compiler/utils/x86/assembler_x86.cc @@ -1291,7 +1291,7 @@ void X86Assembler::LoadDoubleConstant(XmmRegister dst, double value) { pushl(Immediate(High32Bits(constant))); pushl(Immediate(Low32Bits(constant))); movsd(dst, Address(ESP, 0)); - addl(ESP, Immediate(2 * kWordSize)); + addl(ESP, Immediate(2 * sizeof(intptr_t))); } @@ -1303,7 +1303,7 @@ void X86Assembler::FloatNegate(XmmRegister f) { uint32_t d; } float_negate_constant __attribute__((aligned(16))) = { 0x80000000, 0x00000000, 0x80000000, 0x00000000 }; - xorps(f, Address::Absolute(reinterpret_cast<uword>(&float_negate_constant))); + xorps(f, Address::Absolute(reinterpret_cast<uintptr_t>(&float_negate_constant))); } @@ -1313,7 +1313,7 @@ void X86Assembler::DoubleNegate(XmmRegister d) { uint64_t b; } double_negate_constant __attribute__((aligned(16))) = {0x8000000000000000LL, 0x8000000000000000LL}; - xorpd(d, Address::Absolute(reinterpret_cast<uword>(&double_negate_constant))); + xorpd(d, Address::Absolute(reinterpret_cast<uintptr_t>(&double_negate_constant))); } @@ -1323,7 +1323,7 @@ void X86Assembler::DoubleAbs(XmmRegister reg) { uint64_t b; } double_abs_constant __attribute__((aligned(16))) = {0x7FFFFFFFFFFFFFFFLL, 0x7FFFFFFFFFFFFFFFLL}; - andpd(reg, Address::Absolute(reinterpret_cast<uword>(&double_abs_constant))); + andpd(reg, Address::Absolute(reinterpret_cast<uintptr_t>(&double_abs_constant))); } diff --git a/compiler/utils/x86/assembler_x86.h b/compiler/utils/x86/assembler_x86.h index 1f6f7e6957..c7eada34f5 100644 --- a/compiler/utils/x86/assembler_x86.h +++ b/compiler/utils/x86/assembler_x86.h @@ -116,8 +116,8 @@ class Operand { } private: - byte length_; - byte encoding_[6]; + uint8_t length_; + uint8_t encoding_[6]; explicit Operand(Register reg) { SetModRM(3, reg); } @@ -192,7 +192,7 @@ class Address : public Operand { } } - static Address Absolute(uword addr) { + static Address Absolute(uintptr_t addr) { Address result; result.SetModRM(0, EBP); result.SetDisp32(addr); diff --git a/compiler/utils/x86_64/assembler_x86_64.cc b/compiler/utils/x86_64/assembler_x86_64.cc index 705b639ad6..75823e336b 100644 --- a/compiler/utils/x86_64/assembler_x86_64.cc +++ b/compiler/utils/x86_64/assembler_x86_64.cc @@ -1490,7 +1490,7 @@ void X86_64Assembler::LoadDoubleConstant(XmmRegister dst, double value) { pushq(Immediate(High32Bits(constant))); pushq(Immediate(Low32Bits(constant))); movsd(dst, Address(CpuRegister(RSP), 0)); - addq(CpuRegister(RSP), Immediate(2 * kWordSize)); + addq(CpuRegister(RSP), Immediate(2 * sizeof(intptr_t))); } @@ -1502,7 +1502,7 @@ void X86_64Assembler::FloatNegate(XmmRegister f) { uint32_t d; } float_negate_constant __attribute__((aligned(16))) = { 0x80000000, 0x00000000, 0x80000000, 0x00000000 }; - xorps(f, Address::Absolute(reinterpret_cast<uword>(&float_negate_constant))); + xorps(f, Address::Absolute(reinterpret_cast<uintptr_t>(&float_negate_constant))); } @@ -1512,7 +1512,7 @@ void X86_64Assembler::DoubleNegate(XmmRegister d) { uint64_t b; } double_negate_constant __attribute__((aligned(16))) = {0x8000000000000000LL, 0x8000000000000000LL}; - xorpd(d, Address::Absolute(reinterpret_cast<uword>(&double_negate_constant))); + xorpd(d, Address::Absolute(reinterpret_cast<uintptr_t>(&double_negate_constant))); } @@ -1522,7 +1522,7 @@ void X86_64Assembler::DoubleAbs(XmmRegister reg) { uint64_t b; } double_abs_constant __attribute__((aligned(16))) = {0x7FFFFFFFFFFFFFFFLL, 0x7FFFFFFFFFFFFFFFLL}; - andpd(reg, Address::Absolute(reinterpret_cast<uword>(&double_abs_constant))); + andpd(reg, Address::Absolute(reinterpret_cast<uintptr_t>(&double_abs_constant))); } diff --git a/compiler/utils/x86_64/assembler_x86_64.h b/compiler/utils/x86_64/assembler_x86_64.h index 268f72bb66..1d9eba446a 100644 --- a/compiler/utils/x86_64/assembler_x86_64.h +++ b/compiler/utils/x86_64/assembler_x86_64.h @@ -227,7 +227,7 @@ class Address : public Operand { } // If no_rip is true then the Absolute address isn't RIP relative. - static Address Absolute(uword addr, bool no_rip = false) { + static Address Absolute(uintptr_t addr, bool no_rip = false) { Address result; if (no_rip) { result.SetModRM(0, CpuRegister(RSP)); |