diff options
Diffstat (limited to 'runtime')
35 files changed, 29 insertions, 75 deletions
diff --git a/runtime/atomic_integer.h b/runtime/atomic_integer.h index 117e837..6711722 100644 --- a/runtime/atomic_integer.h +++ b/runtime/atomic_integer.h @@ -70,10 +70,11 @@ class AtomicInteger { bool success = android_atomic_cas(expected_value, new_value, &value_) == 0; return success; } + private: volatile int32_t value_; }; -} +} // namespace art #endif // ART_RUNTIME_ATOMIC_INTEGER_H_ diff --git a/runtime/barrier.cc b/runtime/barrier.cc index 250d468..a644998 100644 --- a/runtime/barrier.cc +++ b/runtime/barrier.cc @@ -60,4 +60,4 @@ Barrier::~Barrier() { CHECK(!count_) << "Attempted to destroy barrier with non zero count"; } -} +} // namespace art diff --git a/runtime/barrier_test.cc b/runtime/barrier_test.cc index d26ae9e..298ae56 100644 --- a/runtime/barrier_test.cc +++ b/runtime/barrier_test.cc @@ -32,9 +32,7 @@ class CheckWaitTask : public Task { : barrier_(barrier), count1_(count1), count2_(count2), - count3_(count3) { - - } + count3_(count3) {} void Run(Thread* self) { LOG(INFO) << "Before barrier 1 " << *self; @@ -50,6 +48,7 @@ class CheckWaitTask : public Task { virtual void Finalize() { delete this; } + private: Barrier* const barrier_; AtomicInteger* const count1_; @@ -100,9 +99,7 @@ class CheckPassTask : public Task { CheckPassTask(Barrier* barrier, AtomicInteger* count, size_t subtasks) : barrier_(barrier), count_(count), - subtasks_(subtasks) { - - } + subtasks_(subtasks) {} void Run(Thread* self) { for (size_t i = 0; i < subtasks_; ++i) { diff --git a/runtime/base/histogram-inl.h b/runtime/base/histogram-inl.h index bbca603..d572cf9 100644 --- a/runtime/base/histogram-inl.h +++ b/runtime/base/histogram-inl.h @@ -212,7 +212,6 @@ inline double Histogram<Value>::Percentile(double per) const { DCHECK_GT(cumulative_perc_.size(), 0ull); size_t idx, upper_idx = 0, lower_idx = 0; for (idx = 0; idx < cumulative_perc_.size(); idx++) { - if (per <= cumulative_perc_[idx]) { upper_idx = idx; break; diff --git a/runtime/base/histogram.h b/runtime/base/histogram.h index dfb556b..33a1e65 100644 --- a/runtime/base/histogram.h +++ b/runtime/base/histogram.h @@ -30,7 +30,6 @@ namespace art { // Designed to be simple and used with timing logger in art. template <class Value> class Histogram { - const double kAdjust; const Value kBucketWidth; const size_t kInitialBucketCount; diff --git a/runtime/base/timing_logger.h b/runtime/base/timing_logger.h index 816cbea..0f00a04 100644 --- a/runtime/base/timing_logger.h +++ b/runtime/base/timing_logger.h @@ -50,9 +50,7 @@ namespace base { } // namespace base class CumulativeLogger { - public: - explicit CumulativeLogger(const std::string& name); void prepare_stats(); ~CumulativeLogger(); @@ -68,7 +66,6 @@ class CumulativeLogger { void AddNewLogger(const base::NewTimingLogger& logger) LOCKS_EXCLUDED(lock_); private: - void AddPair(const std::string &label, uint64_t delta_time) EXCLUSIVE_LOCKS_REQUIRED(lock_); void DumpHistogram(std::ostream &os) EXCLUSIVE_LOCKS_REQUIRED(lock_); diff --git a/runtime/debugger.cc b/runtime/debugger.cc index 5a31c87..b502c9a 100644 --- a/runtime/debugger.cc +++ b/runtime/debugger.cc @@ -155,7 +155,6 @@ class DebugInstrumentationListener : public instrumentation::InstrumentationList SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { Dbg::PostException(thread, throw_location, catch_method, catch_dex_pc, exception_object); } - } gDebugInstrumentationListener; // JDWP is allowed unless the Zygote forbids it. @@ -761,7 +760,6 @@ JDWP::JdwpError Dbg::GetContendedMonitor(JDWP::ObjectId thread_id, JDWP::ObjectI JDWP::JdwpError Dbg::GetInstanceCounts(const std::vector<JDWP::RefTypeId>& class_ids, std::vector<uint64_t>& counts) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { - std::vector<mirror::Class*> classes; counts.clear(); for (size_t i = 0; i < class_ids.size(); ++i) { diff --git a/runtime/dex_method_iterator.h b/runtime/dex_method_iterator.h index e915d77..1975e48 100644 --- a/runtime/dex_method_iterator.h +++ b/runtime/dex_method_iterator.h @@ -120,7 +120,6 @@ class DexMethodIterator { } private: - ClassDataItemIterator& GetIterator() const { CHECK(it_.get() != NULL); return *it_.get(); diff --git a/runtime/gc/accounting/heap_bitmap-inl.h b/runtime/gc/accounting/heap_bitmap-inl.h index 7622604..5edea95 100644 --- a/runtime/gc/accounting/heap_bitmap-inl.h +++ b/runtime/gc/accounting/heap_bitmap-inl.h @@ -40,7 +40,6 @@ inline void HeapBitmap::Visit(const Visitor& visitor) { SpaceSetMap* set = *it; set->Visit(visitor); } - } } // namespace accounting diff --git a/runtime/gc/accounting/heap_bitmap.h b/runtime/gc/accounting/heap_bitmap.h index f4b725c..1710579 100644 --- a/runtime/gc/accounting/heap_bitmap.h +++ b/runtime/gc/accounting/heap_bitmap.h @@ -106,7 +106,6 @@ class HeapBitmap { explicit HeapBitmap(Heap* heap) : heap_(heap) {} private: - const Heap* const heap_; void AddContinuousSpaceBitmap(SpaceBitmap* bitmap); diff --git a/runtime/gc/accounting/space_bitmap.cc b/runtime/gc/accounting/space_bitmap.cc index 19f1128..6edc067 100644 --- a/runtime/gc/accounting/space_bitmap.cc +++ b/runtime/gc/accounting/space_bitmap.cc @@ -64,9 +64,7 @@ SpaceBitmap* SpaceBitmap::Create(const std::string& name, byte* heap_begin, size } // Clean up any resources associated with the bitmap. -SpaceBitmap::~SpaceBitmap() { - -} +SpaceBitmap::~SpaceBitmap() {} void SpaceBitmap::SetHeapLimit(uintptr_t new_end) { DCHECK(IsAligned<kBitsPerWord * kAlignment>(new_end)); diff --git a/runtime/gc/accounting/space_bitmap.h b/runtime/gc/accounting/space_bitmap.h index 5a1bfe3..bf4c1ed 100644 --- a/runtime/gc/accounting/space_bitmap.h +++ b/runtime/gc/accounting/space_bitmap.h @@ -174,6 +174,7 @@ class SpaceBitmap { const size_t index = OffsetToIndex(offset); return &bitmap_begin_[index]; } + private: // TODO: heap_end_ is initialized so that the heap bitmap is empty, this doesn't require the -1, // however, we document that this is expected on heap_end_ diff --git a/runtime/gc/collector/garbage_collector.h b/runtime/gc/collector/garbage_collector.h index a22faac..1684664 100644 --- a/runtime/gc/collector/garbage_collector.h +++ b/runtime/gc/collector/garbage_collector.h @@ -79,7 +79,6 @@ class GarbageCollector { void SwapBitmaps() EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_); protected: - // The initial phase. Done without mutators paused. virtual void InitializePhase() = 0; diff --git a/runtime/gc/space/image_space.h b/runtime/gc/space/image_space.h index fde2b41..bdda9fa 100644 --- a/runtime/gc/space/image_space.h +++ b/runtime/gc/space/image_space.h @@ -78,7 +78,6 @@ class ImageSpace : public MemMapSpace { void Dump(std::ostream& os) const; private: - // Tries to initialize an ImageSpace from the given image path, // returning NULL on error. // diff --git a/runtime/gc/space/large_object_space.cc b/runtime/gc/space/large_object_space.cc index f7d776f..6aedd9c 100644 --- a/runtime/gc/space/large_object_space.cc +++ b/runtime/gc/space/large_object_space.cc @@ -49,9 +49,7 @@ void LargeObjectSpace::CopyLiveToMarked() { LargeObjectMapSpace::LargeObjectMapSpace(const std::string& name) : LargeObjectSpace(name), - lock_("large object map space lock", kAllocSpaceLock) { - -} + lock_("large object map space lock", kAllocSpaceLock) {} LargeObjectMapSpace* LargeObjectMapSpace::Create(const std::string& name) { return new LargeObjectMapSpace(name); @@ -147,9 +145,7 @@ FreeListSpace::FreeListSpace(const std::string& name, MemMap* mem_map, byte* beg AddFreeChunk(begin_, end_ - begin_, NULL); } -FreeListSpace::~FreeListSpace() { - -} +FreeListSpace::~FreeListSpace() {} void FreeListSpace::AddFreeChunk(void* address, size_t size, Chunk* previous) { Chunk* chunk = ChunkFromAddr(address); diff --git a/runtime/gc/space/large_object_space.h b/runtime/gc/space/large_object_space.h index db845db..20a4867 100644 --- a/runtime/gc/space/large_object_space.h +++ b/runtime/gc/space/large_object_space.h @@ -60,7 +60,6 @@ class LargeObjectSpace : public DiscontinuousSpace, public AllocSpace { size_t FreeList(Thread* self, size_t num_ptrs, mirror::Object** ptrs); protected: - explicit LargeObjectSpace(const std::string& name); // Approximate number of bytes which have been allocated into the space. @@ -165,6 +164,7 @@ class FreeListSpace : public LargeObjectSpace { DCHECK(m_previous == NULL || (m_previous != NULL && m_previous + m_previous->GetSize() / kAlignment == this)); } + private: size_t m_size; Chunk* m_previous; diff --git a/runtime/image_test.cc b/runtime/image_test.cc index 9ab1d74..ee50118 100644 --- a/runtime/image_test.cc +++ b/runtime/image_test.cc @@ -31,7 +31,6 @@ namespace art { class ImageTest : public CommonTest { - protected: virtual void SetUp() { ReserveImageSpace(); diff --git a/runtime/interpreter/interpreter.cc b/runtime/interpreter/interpreter.cc index 2fb272c..45314c2 100644 --- a/runtime/interpreter/interpreter.cc +++ b/runtime/interpreter/interpreter.cc @@ -366,7 +366,6 @@ static void InterpreterJni(Thread* self, AbstractMethod* method, StringPiece sho { ScopedThreadStateChange tsc(self, kNative); jresult = fn(soa.Env(), rcvr.get(), arg0.get()); - } result->SetL(soa.Decode<Object*>(jresult)); ScopedThreadStateChange tsc(self, kNative); diff --git a/runtime/jdwp/jdwp_handler.cc b/runtime/jdwp/jdwp_handler.cc index 8ef146c..e141496 100644 --- a/runtime/jdwp/jdwp_handler.cc +++ b/runtime/jdwp/jdwp_handler.cc @@ -361,7 +361,6 @@ static JdwpError VM_Capabilities(JdwpState*, Request&, ExpandBuf* reply) static JdwpError VM_CapabilitiesNew(JdwpState*, Request& request, ExpandBuf* reply) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { - // The first few capabilities are the same as those reported by the older call. VM_Capabilities(NULL, request, reply); diff --git a/runtime/mirror/abstract_method.h b/runtime/mirror/abstract_method.h index d909058..bbebece 100644 --- a/runtime/mirror/abstract_method.h +++ b/runtime/mirror/abstract_method.h @@ -497,13 +497,9 @@ class MANAGED AbstractMethod : public Object { DISALLOW_IMPLICIT_CONSTRUCTORS(AbstractMethod); }; -class MANAGED Method : public AbstractMethod { +class MANAGED Method : public AbstractMethod {}; -}; - -class MANAGED Constructor : public AbstractMethod { - -}; +class MANAGED Constructor : public AbstractMethod {}; class MANAGED AbstractMethodClass : public Class { private: diff --git a/runtime/mirror/class.cc b/runtime/mirror/class.cc index 2d2130c..e490d97 100644 --- a/runtime/mirror/class.cc +++ b/runtime/mirror/class.cc @@ -320,13 +320,11 @@ bool Class::IsFieldClass() const { Class* java_lang_Class = GetClass(); Class* java_lang_reflect_Field = java_lang_Class->GetInstanceField(0)->GetClass(); return this == java_lang_reflect_Field; - } bool Class::IsMethodClass() const { return (this == AbstractMethod::GetMethodClass()) || - (this == AbstractMethod::GetConstructorClass()); - + (this == AbstractMethod::GetConstructorClass()); } void Class::SetClassLoader(ClassLoader* new_class_loader) { diff --git a/runtime/oat/runtime/argument_visitor.h b/runtime/oat/runtime/argument_visitor.h index d92ff19..aaf93f7 100644 --- a/runtime/oat/runtime/argument_visitor.h +++ b/runtime/oat/runtime/argument_visitor.h @@ -199,7 +199,6 @@ class QuickArgumentVisitor { uint64_t low_half = *reinterpret_cast<uint32_t*>(GetParamAddress()); uint64_t high_half = *reinterpret_cast<uint32_t*>(stack_args_); return (low_half & 0xffffffffULL) | (high_half << 32); - } void VisitArguments() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { @@ -244,6 +243,6 @@ class QuickArgumentVisitor { bool is_split_long_or_double_; }; -} +} // namespace art #endif // ART_RUNTIME_OAT_RUNTIME_ARGUMENT_VISITOR_H_ diff --git a/runtime/oat_file.cc b/runtime/oat_file.cc index bb8341e..6562633 100644 --- a/runtime/oat_file.cc +++ b/runtime/oat_file.cc @@ -122,7 +122,6 @@ OatFile::~OatFile() { } bool OatFile::Dlopen(const std::string& elf_filename, byte* requested_base) { - char* absolute_path = realpath(elf_filename.c_str(), NULL); if (absolute_path == NULL) { return false; diff --git a/runtime/runtime_support_llvm.cc b/runtime/runtime_support_llvm.cc index cbdefe8..d703db2 100644 --- a/runtime/runtime_support_llvm.cc +++ b/runtime/runtime_support_llvm.cc @@ -50,7 +50,6 @@ using namespace art; extern "C" { - class ShadowFrameCopyVisitor : public StackVisitor { public: explicit ShadowFrameCopyVisitor(Thread* self) : StackVisitor(self, NULL), prev_frame_(NULL), @@ -844,5 +843,4 @@ void art_portable_proxy_invoke_handler_from_code(mirror::AbstractMethod* proxy_m void art_portable_constructor_barrier() { LOG(FATAL) << "Implemented by IRBuilder."; } - } // extern "C" diff --git a/runtime/runtime_support_llvm.h b/runtime/runtime_support_llvm.h index 566f7bc..43ea953 100644 --- a/runtime/runtime_support_llvm.h +++ b/runtime/runtime_support_llvm.h @@ -18,13 +18,10 @@ #define ART_RUNTIME_RUNTIME_SUPPORT_LLVM_H_ extern "C" { - //---------------------------------------------------------------------------- // Runtime Support Function Lookup Callback //---------------------------------------------------------------------------- - void* art_portable_find_runtime_support_func(void* context, const char* name); - } // extern "C" #endif // ART_RUNTIME_RUNTIME_SUPPORT_LLVM_H_ diff --git a/runtime/stack.h b/runtime/stack.h index 0e2c4c5..99ba898 100644 --- a/runtime/stack.h +++ b/runtime/stack.h @@ -554,7 +554,6 @@ class StackVisitor { static void DescribeStack(Thread* thread) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); private: - instrumentation::InstrumentationStackFrame GetInstrumentationStackFrame(uint32_t depth) const; void SanityCheckFrame() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); @@ -567,6 +566,7 @@ class StackVisitor { size_t num_frames_; // Depth of the frame we're currently at. size_t cur_depth_; + protected: Context* const context_; }; @@ -638,6 +638,7 @@ class VmapTable { spill_shifts--; // wind back one as we want the last match return spill_shifts; } + private: const uint16_t* table_; }; diff --git a/runtime/thread.cc b/runtime/thread.cc index dd55195..a1fb862 100644 --- a/runtime/thread.cc +++ b/runtime/thread.cc @@ -2104,9 +2104,7 @@ class ReferenceMapVisitor : public StackVisitor { class RootCallbackVisitor { public: - RootCallbackVisitor(RootVisitor* visitor, void* arg) : visitor_(visitor), arg_(arg) { - - } + RootCallbackVisitor(RootVisitor* visitor, void* arg) : visitor_(visitor), arg_(arg) {} void operator()(const mirror::Object* obj, size_t, const StackVisitor*) const { visitor_(obj, arg_); diff --git a/runtime/thread_pool.cc b/runtime/thread_pool.cc index 784a7ca..067ef2d 100644 --- a/runtime/thread_pool.cc +++ b/runtime/thread_pool.cc @@ -180,10 +180,7 @@ size_t ThreadPool::GetTaskCount(Thread* self) { WorkStealingWorker::WorkStealingWorker(ThreadPool* thread_pool, const std::string& name, size_t stack_size) - : ThreadPoolWorker(thread_pool, name, stack_size), - task_(NULL) { - -} + : ThreadPoolWorker(thread_pool, name, stack_size), task_(NULL) {} void WorkStealingWorker::Run() { Thread* self = Thread::Current(); @@ -254,9 +251,7 @@ void WorkStealingWorker::Run() { } } -WorkStealingWorker::~WorkStealingWorker() { - -} +WorkStealingWorker::~WorkStealingWorker() {} WorkStealingThreadPool::WorkStealingThreadPool(size_t num_threads) : ThreadPool(0), @@ -288,8 +283,6 @@ WorkStealingTask* WorkStealingThreadPool::FindTaskToStealFrom(Thread* self) { return NULL; } -WorkStealingThreadPool::~WorkStealingThreadPool() { - -} +WorkStealingThreadPool::~WorkStealingThreadPool() {} } // namespace art diff --git a/runtime/thread_pool.h b/runtime/thread_pool.h index b9f185d..7b626fb 100644 --- a/runtime/thread_pool.h +++ b/runtime/thread_pool.h @@ -124,9 +124,7 @@ class ThreadPool { class WorkStealingTask : public Task { public: - WorkStealingTask() : ref_count_(0) { - - } + WorkStealingTask() : ref_count_(0) {} size_t GetRefCount() const { return ref_count_; diff --git a/runtime/thread_pool_test.cc b/runtime/thread_pool_test.cc index 9b66318..98178bc 100644 --- a/runtime/thread_pool_test.cc +++ b/runtime/thread_pool_test.cc @@ -105,9 +105,7 @@ class TreeTask : public Task { TreeTask(ThreadPool* const thread_pool, AtomicInteger* count, int depth) : thread_pool_(thread_pool), count_(count), - depth_(depth) { - - } + depth_(depth) {} void Run(Thread* self) { if (depth_ > 1) { diff --git a/runtime/trace.h b/runtime/trace.h index 5bd6a8d..bd9c140 100644 --- a/runtime/trace.h +++ b/runtime/trace.h @@ -78,6 +78,7 @@ class Trace : public instrumentation::InstrumentationListener { mirror::AbstractMethod* catch_method, uint32_t catch_dex_pc, mirror::Throwable* exception_object) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + private: explicit Trace(File* trace_file, int buffer_size, int flags); diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc index 5a70f2a..ff7f594 100644 --- a/runtime/verifier/method_verifier.cc +++ b/runtime/verifier/method_verifier.cc @@ -3749,7 +3749,6 @@ MethodVerifier::MethodSafeCastSet* MethodVerifier::GenerateSafeCastSet() { } MethodVerifier::PcToConcreteMethodMap* MethodVerifier::GenerateDevirtMap() { - // It is risky to rely on reg_types for sharpening in cases of soft // verification, we might end up sharpening to a wrong implementation. Just abort. if (!failure_messages_.empty()) { diff --git a/runtime/verifier/reg_type.h b/runtime/verifier/reg_type.h index c66e7cb..5b806c4 100644 --- a/runtime/verifier/reg_type.h +++ b/runtime/verifier/reg_type.h @@ -309,6 +309,7 @@ class ConflictType : public RegType { // Destroy the singleton instance. static void Destroy(); + private: ConflictType(mirror::Class* klass, const std::string& descriptor, uint16_t cache_id) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) @@ -338,6 +339,7 @@ class UndefinedType : public RegType { // Destroy the singleton instance. static void Destroy(); + private: UndefinedType(mirror::Class* klass, const std::string& descriptor, uint16_t cache_id) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) @@ -875,6 +877,7 @@ class UnresolvedSuperClass : public UnresolvedType { } std::string Dump() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + private: void CheckInvariants() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); @@ -909,6 +912,7 @@ class UnresolvedMergedType : public UnresolvedType { } std::string Dump() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + private: void CheckInvariants() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); diff --git a/runtime/verifier/reg_type_test.cc b/runtime/verifier/reg_type_test.cc index f37edff..d2c9dd6 100644 --- a/runtime/verifier/reg_type_test.cc +++ b/runtime/verifier/reg_type_test.cc @@ -414,7 +414,6 @@ TEST_F(RegTypeReferenceTest, Dump) { EXPECT_EQ(expected, unresolved_merged.Dump()); } - TEST_F(RegTypeReferenceTest, JavalangString) { // Add a class to the cache then look for the same class and make sure it is a // Hit the second time. Then check for the same effect when using @@ -433,8 +432,8 @@ TEST_F(RegTypeReferenceTest, JavalangString) { const RegType& ref_type_unintialized = cache.Uninitialized(ref_type, 0110ull); EXPECT_TRUE(ref_type_unintialized.IsUninitializedReference()); EXPECT_FALSE(ref_type_unintialized.IsUnresolvedAndUninitializedReference()); - } + TEST_F(RegTypeReferenceTest, JavalangObject) { // Add a class to the cache then look for the same class and make sure it is a // Hit the second time. Then I am checking for the same effect when using @@ -474,7 +473,6 @@ TEST_F(RegTypeReferenceTest, Merging) { TEST_F(RegTypeTest, ConstPrecision) { - // Tests creating primitive types types. ScopedObjectAccess soa(Thread::Current()); RegTypeCache cache_new(true); diff --git a/runtime/verifier/register_line.cc b/runtime/verifier/register_line.cc index 3a2145b..d2abaac 100644 --- a/runtime/verifier/register_line.cc +++ b/runtime/verifier/register_line.cc @@ -254,7 +254,6 @@ void RegisterLine::CopyResultRegister2(uint32_t vdst) { SetRegisterTypeWide(vdst, type_l, type_h); // also sets the high result_[0] = verifier_->GetRegTypeCache()->Undefined().GetId(); result_[1] = verifier_->GetRegTypeCache()->Undefined().GetId(); - } } |