am d942853d: am 7c2af0d8: Merge "Remove unnecessary `explicit` qualifiers on constructors."
* commit 'd942853d50c991d9d3c51333a50dee6d81623978':
Remove unnecessary `explicit` qualifiers on constructors.
diff --git a/cmdline/cmdline_parse_result.h b/cmdline/cmdline_parse_result.h
index 717642f..982f178 100644
--- a/cmdline/cmdline_parse_result.h
+++ b/cmdline/cmdline_parse_result.h
@@ -126,7 +126,7 @@
: CmdlineResult(kSuccess), value_(value), has_value_(true) {}
explicit CmdlineParseResult(T&& value)
: CmdlineResult(kSuccess), value_(std::forward<T>(value)), has_value_(true) {}
- explicit CmdlineParseResult()
+ CmdlineParseResult()
: CmdlineResult(kSuccess), value_(), has_value_(false) {}
T value_;
diff --git a/cmdline/cmdline_parser.h b/cmdline/cmdline_parser.h
index cebba65..cfc0967 100644
--- a/cmdline/cmdline_parser.h
+++ b/cmdline/cmdline_parser.h
@@ -497,11 +497,10 @@
friend struct Builder;
// Construct a new parser from the builder. Move all the arguments.
- explicit CmdlineParser(bool ignore_unrecognized,
- std::vector<const char*>&& ignore_list,
- std::shared_ptr<SaveDestination> save_destination,
- std::vector<std::unique_ptr<detail::CmdlineParseArgumentAny>>&&
- completed_arguments)
+ CmdlineParser(bool ignore_unrecognized,
+ std::vector<const char*>&& ignore_list,
+ std::shared_ptr<SaveDestination> save_destination,
+ std::vector<std::unique_ptr<detail::CmdlineParseArgumentAny>>&& completed_arguments)
: ignore_unrecognized_(ignore_unrecognized),
ignore_list_(std::move(ignore_list)),
save_destination_(save_destination),
diff --git a/cmdline/detail/cmdline_parse_argument_detail.h b/cmdline/detail/cmdline_parse_argument_detail.h
index 81ef36b..3009b32 100644
--- a/cmdline/detail/cmdline_parse_argument_detail.h
+++ b/cmdline/detail/cmdline_parse_argument_detail.h
@@ -300,9 +300,9 @@
// be able to parse arguments.
template <typename TArg>
struct CmdlineParseArgument : CmdlineParseArgumentAny {
- explicit CmdlineParseArgument(CmdlineParserArgumentInfo<TArg>&& argument_info,
- std::function<void(TArg&)>&& save_argument,
- std::function<TArg&(void)>&& load_argument)
+ CmdlineParseArgument(CmdlineParserArgumentInfo<TArg>&& argument_info,
+ std::function<void(TArg&)>&& save_argument,
+ std::function<TArg&(void)>&& load_argument)
: argument_info_(std::forward<decltype(argument_info)>(argument_info)),
save_argument_(std::forward<decltype(save_argument)>(save_argument)),
load_argument_(std::forward<decltype(load_argument)>(load_argument)) {
diff --git a/cmdline/token_range.h b/cmdline/token_range.h
index 5b54384..3358067 100644
--- a/cmdline/token_range.h
+++ b/cmdline/token_range.h
@@ -45,7 +45,7 @@
// Copying-from-iterator constructor
template <typename ForwardIterator>
- explicit TokenRange(ForwardIterator it_begin, ForwardIterator it_end)
+ TokenRange(ForwardIterator it_begin, ForwardIterator it_end)
: token_list_(new TokenList(it_begin, it_end)),
begin_(token_list_->begin()),
end_(token_list_->end())
diff --git a/compiler/compiler.h b/compiler/compiler.h
index fcd3434..01ca46e 100644
--- a/compiler/compiler.h
+++ b/compiler/compiler.h
@@ -89,7 +89,7 @@
const DexFile& dex_file);
protected:
- explicit Compiler(CompilerDriver* driver, uint64_t warning) :
+ Compiler(CompilerDriver* driver, uint64_t warning) :
driver_(driver), maximum_compilation_time_before_warning_(warning) {
}
diff --git a/compiler/dex/compiler_ir.h b/compiler/dex/compiler_ir.h
index d28df1d..5203355 100644
--- a/compiler/dex/compiler_ir.h
+++ b/compiler/dex/compiler_ir.h
@@ -129,7 +129,7 @@
* Union containing the option value of either type.
*/
union OptionContainer {
- explicit OptionContainer(const OptionContainer& c, OptionType t) {
+ OptionContainer(const OptionContainer& c, OptionType t) {
if (t == kString) {
DCHECK(c.s != nullptr);
s = strndup(c.s, kOptionStringMaxLength);
diff --git a/compiler/dex/mir_field_info.h b/compiler/dex/mir_field_info.h
index 04c58ac..053029d 100644
--- a/compiler/dex/mir_field_info.h
+++ b/compiler/dex/mir_field_info.h
@@ -138,7 +138,7 @@
REQUIRES(!Locks::mutator_lock_);
// Construct an unresolved instance field lowering info.
- explicit MirIFieldLoweringInfo(uint16_t field_idx, DexMemAccessType type, bool is_quickened)
+ MirIFieldLoweringInfo(uint16_t field_idx, DexMemAccessType type, bool is_quickened)
: MirFieldInfo(field_idx,
kFlagIsVolatile | (is_quickened ? kFlagIsQuickened : 0u),
type), // Without kFlagIsStatic.
@@ -195,7 +195,7 @@
REQUIRES(!Locks::mutator_lock_);
// Construct an unresolved static field lowering info.
- explicit MirSFieldLoweringInfo(uint16_t field_idx, DexMemAccessType type)
+ MirSFieldLoweringInfo(uint16_t field_idx, DexMemAccessType type)
: MirFieldInfo(field_idx, kFlagIsVolatile | kFlagIsStatic, type),
field_offset_(0u),
storage_index_(DexFile::kDexNoIndex) {
diff --git a/compiler/dex/mir_graph.h b/compiler/dex/mir_graph.h
index 23b7c42..8bf709a 100644
--- a/compiler/dex/mir_graph.h
+++ b/compiler/dex/mir_graph.h
@@ -261,7 +261,7 @@
uint32_t arg[5]; /* vC/D/E/F/G in invoke or filled-new-array */
Instruction::Code opcode;
- explicit DecodedInstruction():vA(0), vB(0), vB_wide(0), vC(0), opcode(Instruction::NOP) {
+ DecodedInstruction() : vA(0), vB(0), vB_wide(0), vC(0), opcode(Instruction::NOP) {
}
/*
@@ -353,7 +353,7 @@
uint32_t method_lowering_info;
} meta;
- explicit MIR() : offset(0), optimization_flags(0), m_unit_index(0), bb(NullBasicBlockId),
+ MIR() : offset(0), optimization_flags(0), m_unit_index(0), bb(NullBasicBlockId),
next(nullptr), ssa_rep(nullptr) {
memset(&meta, 0, sizeof(meta));
}
diff --git a/compiler/dex/pass_driver_me.h b/compiler/dex/pass_driver_me.h
index cbe4a02..d0af71c 100644
--- a/compiler/dex/pass_driver_me.h
+++ b/compiler/dex/pass_driver_me.h
@@ -36,7 +36,7 @@
class PassDriverME: public PassDriver {
public:
- explicit PassDriverME(const PassManager* const pass_manager, CompilationUnit* cu)
+ PassDriverME(const PassManager* const pass_manager, CompilationUnit* cu)
: PassDriver(pass_manager), pass_me_data_holder_(), dump_cfg_folder_("/sdcard/") {
pass_me_data_holder_.bb = nullptr;
pass_me_data_holder_.c_unit = cu;
@@ -314,4 +314,3 @@
};
} // namespace art
#endif // ART_COMPILER_DEX_PASS_DRIVER_ME_H_
-
diff --git a/compiler/dex/pass_driver_me_opts.h b/compiler/dex/pass_driver_me_opts.h
index e94c189..c8093d0 100644
--- a/compiler/dex/pass_driver_me_opts.h
+++ b/compiler/dex/pass_driver_me_opts.h
@@ -29,9 +29,9 @@
class PassDriverMEOpts : public PassDriverME {
public:
- explicit PassDriverMEOpts(const PassManager* const manager,
- const PassManager* const post_opt_pass_manager,
- CompilationUnit* cu)
+ PassDriverMEOpts(const PassManager* const manager,
+ const PassManager* const post_opt_pass_manager,
+ CompilationUnit* cu)
: PassDriverME(manager, cu), post_opt_pass_manager_(post_opt_pass_manager) {
}
diff --git a/compiler/dex/pass_driver_me_post_opt.h b/compiler/dex/pass_driver_me_post_opt.h
index 9e03c4e..94176db 100644
--- a/compiler/dex/pass_driver_me_post_opt.h
+++ b/compiler/dex/pass_driver_me_post_opt.h
@@ -28,7 +28,7 @@
class PassDriverMEPostOpt : public PassDriverME {
public:
- explicit PassDriverMEPostOpt(const PassManager* const manager, CompilationUnit* cu)
+ PassDriverMEPostOpt(const PassManager* const manager, CompilationUnit* cu)
: PassDriverME(manager, cu) {
}
diff --git a/compiler/dex/quick/lazy_debug_frame_opcode_writer.h b/compiler/dex/quick/lazy_debug_frame_opcode_writer.h
index 94ffd7f..3e9fb96 100644
--- a/compiler/dex/quick/lazy_debug_frame_opcode_writer.h
+++ b/compiler/dex/quick/lazy_debug_frame_opcode_writer.h
@@ -40,12 +40,11 @@
const ArenaVector<uint8_t>* Patch(size_t code_size);
- explicit LazyDebugFrameOpCodeWriter(LIR** last_lir_insn, bool enable_writes,
- ArenaAllocator* allocator)
- : Base(enable_writes, allocator->Adapter()),
- last_lir_insn_(last_lir_insn),
- advances_(allocator->Adapter()),
- patched_(false) {
+ LazyDebugFrameOpCodeWriter(LIR** last_lir_insn, bool enable_writes, ArenaAllocator* allocator)
+ : Base(enable_writes, allocator->Adapter()),
+ last_lir_insn_(last_lir_insn),
+ advances_(allocator->Adapter()),
+ patched_(false) {
}
private:
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index 4de9c73..5718be9 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -89,19 +89,19 @@
// enabled. "image_classes" lets the compiler know what classes it
// can assume will be in the image, with null implying all available
// classes.
- explicit CompilerDriver(const CompilerOptions* compiler_options,
- VerificationResults* verification_results,
- DexFileToMethodInlinerMap* method_inliner_map,
- Compiler::Kind compiler_kind,
- InstructionSet instruction_set,
- const InstructionSetFeatures* instruction_set_features,
- bool image, std::unordered_set<std::string>* image_classes,
- std::unordered_set<std::string>* compiled_classes,
- std::unordered_set<std::string>* compiled_methods,
- size_t thread_count, bool dump_stats, bool dump_passes,
- const std::string& dump_cfg_file_name,
- CumulativeLogger* timer, int swap_fd,
- const std::string& profile_file);
+ CompilerDriver(const CompilerOptions* compiler_options,
+ VerificationResults* verification_results,
+ DexFileToMethodInlinerMap* method_inliner_map,
+ Compiler::Kind compiler_kind,
+ InstructionSet instruction_set,
+ const InstructionSetFeatures* instruction_set_features,
+ bool image, std::unordered_set<std::string>* image_classes,
+ std::unordered_set<std::string>* compiled_classes,
+ std::unordered_set<std::string>* compiled_methods,
+ size_t thread_count, bool dump_stats, bool dump_passes,
+ const std::string& dump_cfg_file_name,
+ CumulativeLogger* timer, int swap_fd,
+ const std::string& profile_file);
~CompilerDriver();
diff --git a/compiler/jni/quick/arm/calling_convention_arm.h b/compiler/jni/quick/arm/calling_convention_arm.h
index dbecb8e..35b5093 100644
--- a/compiler/jni/quick/arm/calling_convention_arm.h
+++ b/compiler/jni/quick/arm/calling_convention_arm.h
@@ -48,7 +48,7 @@
class ArmJniCallingConvention FINAL : public JniCallingConvention {
public:
- explicit ArmJniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
+ ArmJniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
~ArmJniCallingConvention() OVERRIDE {}
// Calling convention
ManagedRegister ReturnRegister() OVERRIDE;
diff --git a/compiler/jni/quick/arm64/calling_convention_arm64.h b/compiler/jni/quick/arm64/calling_convention_arm64.h
index 9fd3265..37c92b2 100644
--- a/compiler/jni/quick/arm64/calling_convention_arm64.h
+++ b/compiler/jni/quick/arm64/calling_convention_arm64.h
@@ -48,7 +48,7 @@
class Arm64JniCallingConvention FINAL : public JniCallingConvention {
public:
- explicit Arm64JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
+ Arm64JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
~Arm64JniCallingConvention() OVERRIDE {}
// Calling convention
ManagedRegister ReturnRegister() OVERRIDE;
diff --git a/compiler/jni/quick/calling_convention.h b/compiler/jni/quick/calling_convention.h
index c9b595a..243d124 100644
--- a/compiler/jni/quick/calling_convention.h
+++ b/compiler/jni/quick/calling_convention.h
@@ -348,8 +348,8 @@
kObjectOrClass = 1
};
- explicit JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty,
- size_t frame_pointer_size)
+ JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty,
+ size_t frame_pointer_size)
: CallingConvention(is_static, is_synchronized, shorty, frame_pointer_size) {}
// Number of stack slots for outgoing arguments, above which the handle scope is
diff --git a/compiler/jni/quick/mips/calling_convention_mips.h b/compiler/jni/quick/mips/calling_convention_mips.h
index 8d82dce..dc45432 100644
--- a/compiler/jni/quick/mips/calling_convention_mips.h
+++ b/compiler/jni/quick/mips/calling_convention_mips.h
@@ -48,7 +48,7 @@
class MipsJniCallingConvention FINAL : public JniCallingConvention {
public:
- explicit MipsJniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
+ MipsJniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
~MipsJniCallingConvention() OVERRIDE {}
// Calling convention
ManagedRegister ReturnRegister() OVERRIDE;
diff --git a/compiler/jni/quick/mips64/calling_convention_mips64.h b/compiler/jni/quick/mips64/calling_convention_mips64.h
index dc9273b..3d6aab7 100644
--- a/compiler/jni/quick/mips64/calling_convention_mips64.h
+++ b/compiler/jni/quick/mips64/calling_convention_mips64.h
@@ -48,7 +48,7 @@
class Mips64JniCallingConvention FINAL : public JniCallingConvention {
public:
- explicit Mips64JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
+ Mips64JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
~Mips64JniCallingConvention() OVERRIDE {}
// Calling convention
ManagedRegister ReturnRegister() OVERRIDE;
diff --git a/compiler/jni/quick/x86/calling_convention_x86.h b/compiler/jni/quick/x86/calling_convention_x86.h
index b1b3598..cdf0956 100644
--- a/compiler/jni/quick/x86/calling_convention_x86.h
+++ b/compiler/jni/quick/x86/calling_convention_x86.h
@@ -26,8 +26,7 @@
class X86ManagedRuntimeCallingConvention FINAL : public ManagedRuntimeCallingConvention {
public:
- explicit X86ManagedRuntimeCallingConvention(bool is_static, bool is_synchronized,
- const char* shorty)
+ X86ManagedRuntimeCallingConvention(bool is_static, bool is_synchronized, const char* shorty)
: ManagedRuntimeCallingConvention(is_static, is_synchronized, shorty, kFramePointerSize),
gpr_arg_count_(0) {}
~X86ManagedRuntimeCallingConvention() OVERRIDE {}
@@ -51,7 +50,7 @@
class X86JniCallingConvention FINAL : public JniCallingConvention {
public:
- explicit X86JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
+ X86JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
~X86JniCallingConvention() OVERRIDE {}
// Calling convention
ManagedRegister ReturnRegister() OVERRIDE;
diff --git a/compiler/jni/quick/x86_64/calling_convention_x86_64.h b/compiler/jni/quick/x86_64/calling_convention_x86_64.h
index 7a90c6e..6e47c9f 100644
--- a/compiler/jni/quick/x86_64/calling_convention_x86_64.h
+++ b/compiler/jni/quick/x86_64/calling_convention_x86_64.h
@@ -26,8 +26,7 @@
class X86_64ManagedRuntimeCallingConvention FINAL : public ManagedRuntimeCallingConvention {
public:
- explicit X86_64ManagedRuntimeCallingConvention(bool is_static, bool is_synchronized,
- const char* shorty)
+ X86_64ManagedRuntimeCallingConvention(bool is_static, bool is_synchronized, const char* shorty)
: ManagedRuntimeCallingConvention(is_static, is_synchronized, shorty, kFramePointerSize) {}
~X86_64ManagedRuntimeCallingConvention() OVERRIDE {}
// Calling convention
@@ -47,7 +46,7 @@
class X86_64JniCallingConvention FINAL : public JniCallingConvention {
public:
- explicit X86_64JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
+ X86_64JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
~X86_64JniCallingConvention() OVERRIDE {}
// Calling convention
ManagedRegister ReturnRegister() OVERRIDE;
diff --git a/compiler/oat_writer.h b/compiler/oat_writer.h
index 3baf438..760fb7c 100644
--- a/compiler/oat_writer.h
+++ b/compiler/oat_writer.h
@@ -178,7 +178,7 @@
class OatDexFile {
public:
- explicit OatDexFile(size_t offset, const DexFile& dex_file);
+ OatDexFile(size_t offset, const DexFile& dex_file);
size_t SizeOf() const;
void UpdateChecksum(OatHeader* oat_header) const;
bool Write(OatWriter* oat_writer, OutputStream* out, const size_t file_offset) const;
@@ -200,10 +200,10 @@
class OatClass {
public:
- explicit OatClass(size_t offset,
- const std::vector<CompiledMethod*>& compiled_methods,
- uint32_t num_non_null_compiled_methods,
- mirror::Class::Status status);
+ OatClass(size_t offset,
+ const std::vector<CompiledMethod*>& compiled_methods,
+ uint32_t num_non_null_compiled_methods,
+ mirror::Class::Status status);
~OatClass();
size_t GetOatMethodOffsetsOffsetFromOatHeader(size_t class_def_method_index_) const;
size_t GetOatMethodOffsetsOffsetFromOatClass(size_t class_def_method_index_) const;
diff --git a/compiler/optimizing/code_generator_arm64.cc b/compiler/optimizing/code_generator_arm64.cc
index e5b6df5..b8ac421 100644
--- a/compiler/optimizing/code_generator_arm64.cc
+++ b/compiler/optimizing/code_generator_arm64.cc
@@ -360,8 +360,7 @@
class SuspendCheckSlowPathARM64 : public SlowPathCodeARM64 {
public:
- explicit SuspendCheckSlowPathARM64(HSuspendCheck* instruction,
- HBasicBlock* successor)
+ SuspendCheckSlowPathARM64(HSuspendCheck* instruction, HBasicBlock* successor)
: instruction_(instruction), successor_(successor) {}
void EmitNativeCode(CodeGenerator* codegen) OVERRIDE {
diff --git a/compiler/optimizing/code_generator_arm64.h b/compiler/optimizing/code_generator_arm64.h
index 2c61038..ac7ee10 100644
--- a/compiler/optimizing/code_generator_arm64.h
+++ b/compiler/optimizing/code_generator_arm64.h
@@ -191,7 +191,7 @@
class LocationsBuilderARM64 : public HGraphVisitor {
public:
- explicit LocationsBuilderARM64(HGraph* graph, CodeGeneratorARM64* codegen)
+ LocationsBuilderARM64(HGraph* graph, CodeGeneratorARM64* codegen)
: HGraphVisitor(graph), codegen_(codegen) {}
#define DECLARE_VISIT_INSTRUCTION(name, super) \
diff --git a/compiler/optimizing/code_generator_mips64.cc b/compiler/optimizing/code_generator_mips64.cc
index e5761eb..167e025 100644
--- a/compiler/optimizing/code_generator_mips64.cc
+++ b/compiler/optimizing/code_generator_mips64.cc
@@ -294,8 +294,7 @@
class SuspendCheckSlowPathMIPS64 : public SlowPathCodeMIPS64 {
public:
- explicit SuspendCheckSlowPathMIPS64(HSuspendCheck* instruction,
- HBasicBlock* successor)
+ SuspendCheckSlowPathMIPS64(HSuspendCheck* instruction, HBasicBlock* successor)
: instruction_(instruction), successor_(successor) {}
void EmitNativeCode(CodeGenerator* codegen) OVERRIDE {
diff --git a/compiler/optimizing/code_generator_x86.cc b/compiler/optimizing/code_generator_x86.cc
index 5a77c82..091a3e5 100644
--- a/compiler/optimizing/code_generator_x86.cc
+++ b/compiler/optimizing/code_generator_x86.cc
@@ -93,7 +93,7 @@
class DivRemMinusOneSlowPathX86 : public SlowPathCodeX86 {
public:
- explicit DivRemMinusOneSlowPathX86(Register reg, bool is_div) : reg_(reg), is_div_(is_div) {}
+ DivRemMinusOneSlowPathX86(Register reg, bool is_div) : reg_(reg), is_div_(is_div) {}
void EmitNativeCode(CodeGenerator* codegen) OVERRIDE {
__ Bind(GetEntryLabel());
diff --git a/compiler/optimizing/code_generator_x86_64.cc b/compiler/optimizing/code_generator_x86_64.cc
index 3730478..2c5cef3 100644
--- a/compiler/optimizing/code_generator_x86_64.cc
+++ b/compiler/optimizing/code_generator_x86_64.cc
@@ -95,7 +95,7 @@
class DivRemMinusOneSlowPathX86_64 : public SlowPathCodeX86_64 {
public:
- explicit DivRemMinusOneSlowPathX86_64(Register reg, Primitive::Type type, bool is_div)
+ DivRemMinusOneSlowPathX86_64(Register reg, Primitive::Type type, bool is_div)
: cpu_reg_(CpuRegister(reg)), type_(type), is_div_(is_div) {}
void EmitNativeCode(CodeGenerator* codegen) OVERRIDE {
@@ -129,7 +129,7 @@
class SuspendCheckSlowPathX86_64 : public SlowPathCodeX86_64 {
public:
- explicit SuspendCheckSlowPathX86_64(HSuspendCheck* instruction, HBasicBlock* successor)
+ SuspendCheckSlowPathX86_64(HSuspendCheck* instruction, HBasicBlock* successor)
: instruction_(instruction), successor_(successor) {}
void EmitNativeCode(CodeGenerator* codegen) OVERRIDE {
diff --git a/compiler/optimizing/intrinsics_arm.h b/compiler/optimizing/intrinsics_arm.h
index c21e9c0..f013bd6 100644
--- a/compiler/optimizing/intrinsics_arm.h
+++ b/compiler/optimizing/intrinsics_arm.h
@@ -33,8 +33,7 @@
class IntrinsicLocationsBuilderARM FINAL : public IntrinsicVisitor {
public:
- explicit IntrinsicLocationsBuilderARM(ArenaAllocator* arena,
- const ArmInstructionSetFeatures& features)
+ IntrinsicLocationsBuilderARM(ArenaAllocator* arena, const ArmInstructionSetFeatures& features)
: arena_(arena), features_(features) {}
// Define visitor methods.
diff --git a/compiler/optimizing/nodes.h b/compiler/optimizing/nodes.h
index e6df429..89709fa 100644
--- a/compiler/optimizing/nodes.h
+++ b/compiler/optimizing/nodes.h
@@ -3213,7 +3213,7 @@
class HNeg : public HUnaryOperation {
public:
- explicit HNeg(Primitive::Type result_type, HInstruction* input)
+ HNeg(Primitive::Type result_type, HInstruction* input)
: HUnaryOperation(result_type, input) {}
template <typename T> T Compute(T x) const { return -x; }
@@ -3654,7 +3654,7 @@
class HNot : public HUnaryOperation {
public:
- explicit HNot(Primitive::Type result_type, HInstruction* input)
+ HNot(Primitive::Type result_type, HInstruction* input)
: HUnaryOperation(result_type, input) {}
bool CanBeMoved() const OVERRIDE { return true; }
@@ -4320,7 +4320,7 @@
*/
class HClinitCheck : public HExpression<1> {
public:
- explicit HClinitCheck(HLoadClass* constant, uint32_t dex_pc)
+ HClinitCheck(HLoadClass* constant, uint32_t dex_pc)
: HExpression(
Primitive::kPrimNot,
SideEffects::AllChanges()), // Assume write/read on all fields/arrays.
diff --git a/compiler/utils/arm/assembler_arm.h b/compiler/utils/arm/assembler_arm.h
index 5d85d11..ef60fef 100644
--- a/compiler/utils/arm/assembler_arm.h
+++ b/compiler/utils/arm/assembler_arm.h
@@ -888,7 +888,7 @@
// Slowpath entered when Thread::Current()->_exception is non-null
class ArmExceptionSlowPath FINAL : public SlowPath {
public:
- explicit ArmExceptionSlowPath(ArmManagedRegister scratch, size_t stack_adjust)
+ ArmExceptionSlowPath(ArmManagedRegister scratch, size_t stack_adjust)
: scratch_(scratch), stack_adjust_(stack_adjust) {
}
void Emit(Assembler *sp_asm) OVERRIDE;
diff --git a/compiler/utils/arm64/assembler_arm64.h b/compiler/utils/arm64/assembler_arm64.h
index 05882a3..8e85fe9 100644
--- a/compiler/utils/arm64/assembler_arm64.h
+++ b/compiler/utils/arm64/assembler_arm64.h
@@ -254,7 +254,7 @@
class Arm64Exception {
private:
- explicit Arm64Exception(Arm64ManagedRegister scratch, size_t stack_adjust)
+ Arm64Exception(Arm64ManagedRegister scratch, size_t stack_adjust)
: scratch_(scratch), stack_adjust_(stack_adjust) {
}
diff --git a/compiler/utils/dedupe_set.h b/compiler/utils/dedupe_set.h
index 8cdb180..2c4a689 100644
--- a/compiler/utils/dedupe_set.h
+++ b/compiler/utils/dedupe_set.h
@@ -99,7 +99,7 @@
return hashed_key.store_ptr;
}
- explicit DedupeSet(const char* set_name, SwapAllocator<void>& alloc)
+ DedupeSet(const char* set_name, SwapAllocator<void>& alloc)
: allocator_(alloc), hash_time_(0) {
for (HashType i = 0; i < kShard; ++i) {
std::ostringstream oss;
diff --git a/compiler/utils/dex_cache_arrays_layout.h b/compiler/utils/dex_cache_arrays_layout.h
index 8f98ea1..2a109bd 100644
--- a/compiler/utils/dex_cache_arrays_layout.h
+++ b/compiler/utils/dex_cache_arrays_layout.h
@@ -37,7 +37,7 @@
}
// Construct a layout for a particular dex file.
- explicit DexCacheArraysLayout(size_t pointer_size, const DexFile* dex_file);
+ DexCacheArraysLayout(size_t pointer_size, const DexFile* dex_file);
bool Valid() const {
return Size() != 0u;
diff --git a/compiler/utils/managed_register.h b/compiler/utils/managed_register.h
index bb62bca..893daff 100644
--- a/compiler/utils/managed_register.h
+++ b/compiler/utils/managed_register.h
@@ -95,7 +95,7 @@
explicit ManagedRegisterSpill(const ManagedRegister& other)
: ManagedRegister(other), size_(-1), spill_offset_(-1) { }
- explicit ManagedRegisterSpill(const ManagedRegister& other, int32_t size)
+ ManagedRegisterSpill(const ManagedRegister& other, int32_t size)
: ManagedRegister(other), size_(size), spill_offset_(-1) { }
int32_t getSpillOffset() {
diff --git a/compiler/utils/mips/assembler_mips.h b/compiler/utils/mips/assembler_mips.h
index 0d1b82c..df95dad 100644
--- a/compiler/utils/mips/assembler_mips.h
+++ b/compiler/utils/mips/assembler_mips.h
@@ -283,7 +283,7 @@
// Slowpath entered when Thread::Current()->_exception is non-null
class MipsExceptionSlowPath FINAL : public SlowPath {
public:
- explicit MipsExceptionSlowPath(MipsManagedRegister scratch, size_t stack_adjust)
+ MipsExceptionSlowPath(MipsManagedRegister scratch, size_t stack_adjust)
: scratch_(scratch), stack_adjust_(stack_adjust) {}
virtual void Emit(Assembler *sp_asm) OVERRIDE;
private:
diff --git a/compiler/utils/mips64/assembler_mips64.h b/compiler/utils/mips64/assembler_mips64.h
index 47b146a..31130ea 100644
--- a/compiler/utils/mips64/assembler_mips64.h
+++ b/compiler/utils/mips64/assembler_mips64.h
@@ -354,7 +354,7 @@
// Slowpath entered when Thread::Current()->_exception is non-null
class Mips64ExceptionSlowPath FINAL : public SlowPath {
public:
- explicit Mips64ExceptionSlowPath(Mips64ManagedRegister scratch, size_t stack_adjust)
+ Mips64ExceptionSlowPath(Mips64ManagedRegister scratch, size_t stack_adjust)
: scratch_(scratch), stack_adjust_(stack_adjust) {}
virtual void Emit(Assembler *sp_asm) OVERRIDE;
private:
diff --git a/compiler/utils/x86/assembler_x86.h b/compiler/utils/x86/assembler_x86.h
index d9c1b40..37c69fe 100644
--- a/compiler/utils/x86/assembler_x86.h
+++ b/compiler/utils/x86/assembler_x86.h
@@ -205,7 +205,7 @@
class X86Assembler FINAL : public Assembler {
public:
- explicit X86Assembler() {}
+ X86Assembler() {}
virtual ~X86Assembler() {}
/*
diff --git a/disassembler/disassembler_arm.cc b/disassembler/disassembler_arm.cc
index d1d3481..03fac18 100644
--- a/disassembler/disassembler_arm.cc
+++ b/disassembler/disassembler_arm.cc
@@ -201,14 +201,13 @@
}
struct FpRegister {
- explicit FpRegister(uint32_t instr, uint16_t at_bit, uint16_t extra_at_bit) {
+ FpRegister(uint32_t instr, uint16_t at_bit, uint16_t extra_at_bit) {
size = (instr >> 8) & 1;
uint32_t Vn = (instr >> at_bit) & 0xF;
uint32_t N = (instr >> extra_at_bit) & 1;
r = (size != 0 ? ((N << 4) | Vn) : ((Vn << 1) | N));
}
- explicit FpRegister(uint32_t instr, uint16_t at_bit, uint16_t extra_at_bit,
- uint32_t forced_size) {
+ FpRegister(uint32_t instr, uint16_t at_bit, uint16_t extra_at_bit, uint32_t forced_size) {
size = forced_size;
uint32_t Vn = (instr >> at_bit) & 0xF;
uint32_t N = (instr >> extra_at_bit) & 1;
diff --git a/disassembler/disassembler_mips.h b/disassembler/disassembler_mips.h
index 4f70a9b..b0e49b3 100644
--- a/disassembler/disassembler_mips.h
+++ b/disassembler/disassembler_mips.h
@@ -26,10 +26,11 @@
class DisassemblerMips FINAL : public Disassembler {
public:
- explicit DisassemblerMips(DisassemblerOptions* options, bool is64bit) : Disassembler(options),
- is64bit_(is64bit),
- last_ptr_(nullptr),
- last_instr_(0) {}
+ DisassemblerMips(DisassemblerOptions* options, bool is64bit)
+ : Disassembler(options),
+ is64bit_(is64bit),
+ last_ptr_(nullptr),
+ last_instr_(0) {}
size_t Dump(std::ostream& os, const uint8_t* begin) OVERRIDE;
void Dump(std::ostream& os, const uint8_t* begin, const uint8_t* end) OVERRIDE;
diff --git a/oatdump/oatdump.cc b/oatdump/oatdump.cc
index b61cfc9..5e29ca7 100644
--- a/oatdump/oatdump.cc
+++ b/oatdump/oatdump.cc
@@ -107,7 +107,7 @@
const OatFile* oat_file_;
};
- explicit OatSymbolizer(const OatFile* oat_file, const std::string& output_name) :
+ OatSymbolizer(const OatFile* oat_file, const std::string& output_name) :
oat_file_(oat_file), builder_(nullptr),
output_name_(output_name.empty() ? "symbolized.oat" : output_name) {
}
@@ -346,7 +346,7 @@
class OatDumper {
public:
- explicit OatDumper(const OatFile& oat_file, const OatDumperOptions& options)
+ OatDumper(const OatFile& oat_file, const OatDumperOptions& options)
: oat_file_(oat_file),
oat_dex_files_(oat_file.GetOatDexFiles()),
options_(options),
@@ -1453,8 +1453,8 @@
class ImageDumper {
public:
- explicit ImageDumper(std::ostream* os, gc::space::ImageSpace& image_space,
- const ImageHeader& image_header, OatDumperOptions* oat_dumper_options)
+ ImageDumper(std::ostream* os, gc::space::ImageSpace& image_space,
+ const ImageHeader& image_header, OatDumperOptions* oat_dumper_options)
: os_(os),
vios_(os),
indent1_(&vios_),
@@ -2019,7 +2019,7 @@
std::vector<double> method_outlier_expansion;
std::vector<std::pair<std::string, size_t>> oat_dex_file_sizes;
- explicit Stats()
+ Stats()
: oat_file_bytes(0),
file_bytes(0),
header_bytes(0),
diff --git a/runtime/arch/arm64/instruction_set_features_arm64.h b/runtime/arch/arm64/instruction_set_features_arm64.h
index e59ff58..805131f 100644
--- a/runtime/arch/arm64/instruction_set_features_arm64.h
+++ b/runtime/arch/arm64/instruction_set_features_arm64.h
@@ -83,9 +83,7 @@
std::string* error_msg) const OVERRIDE;
private:
- explicit Arm64InstructionSetFeatures(bool smp,
- bool needs_a53_835769_fix,
- bool needs_a53_843419_fix)
+ Arm64InstructionSetFeatures(bool smp, bool needs_a53_835769_fix, bool needs_a53_843419_fix)
: InstructionSetFeatures(smp),
fix_cortex_a53_835769_(needs_a53_835769_fix),
fix_cortex_a53_843419_(needs_a53_843419_fix) {
diff --git a/runtime/base/arena_allocator.h b/runtime/base/arena_allocator.h
index c4b36ee..05c66f0 100644
--- a/runtime/base/arena_allocator.h
+++ b/runtime/base/arena_allocator.h
@@ -170,7 +170,7 @@
class MemMapArena FINAL : public Arena {
public:
- explicit MemMapArena(size_t size, bool low_4gb);
+ MemMapArena(size_t size, bool low_4gb);
virtual ~MemMapArena();
void Release() OVERRIDE;
diff --git a/runtime/base/arena_containers.h b/runtime/base/arena_containers.h
index d6c4a54..a7aafdf 100644
--- a/runtime/base/arena_containers.h
+++ b/runtime/base/arena_containers.h
@@ -134,7 +134,7 @@
typedef ArenaAllocatorAdapter<U> other;
};
- explicit ArenaAllocatorAdapter(ArenaAllocator* arena_allocator, ArenaAllocKind kind)
+ ArenaAllocatorAdapter(ArenaAllocator* arena_allocator, ArenaAllocKind kind)
: ArenaAllocatorAdapterKind(kind),
arena_allocator_(arena_allocator) {
}
diff --git a/runtime/base/mutex.h b/runtime/base/mutex.h
index 2801fb7..848c904 100644
--- a/runtime/base/mutex.h
+++ b/runtime/base/mutex.h
@@ -437,7 +437,7 @@
// (Signal) or all at once (Broadcast).
class ConditionVariable {
public:
- explicit ConditionVariable(const char* name, Mutex& mutex);
+ ConditionVariable(const char* name, Mutex& mutex);
~ConditionVariable();
void Broadcast(Thread* self);
@@ -475,7 +475,7 @@
// upon destruction.
class SCOPED_CAPABILITY MutexLock {
public:
- explicit MutexLock(Thread* self, Mutex& mu) ACQUIRE(mu) : self_(self), mu_(mu) {
+ MutexLock(Thread* self, Mutex& mu) ACQUIRE(mu) : self_(self), mu_(mu) {
mu_.ExclusiveLock(self_);
}
@@ -495,7 +495,7 @@
// construction and releases it upon destruction.
class SCOPED_CAPABILITY ReaderMutexLock {
public:
- explicit ReaderMutexLock(Thread* self, ReaderWriterMutex& mu) ACQUIRE(mu) :
+ ReaderMutexLock(Thread* self, ReaderWriterMutex& mu) ACQUIRE(mu) :
self_(self), mu_(mu) {
mu_.SharedLock(self_);
}
@@ -517,7 +517,7 @@
// construction and releases it upon destruction.
class SCOPED_CAPABILITY WriterMutexLock {
public:
- explicit WriterMutexLock(Thread* self, ReaderWriterMutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) :
+ WriterMutexLock(Thread* self, ReaderWriterMutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) :
self_(self), mu_(mu) {
mu_.ExclusiveLock(self_);
}
diff --git a/runtime/base/timing_logger.h b/runtime/base/timing_logger.h
index e10cd24..a5344db 100644
--- a/runtime/base/timing_logger.h
+++ b/runtime/base/timing_logger.h
@@ -131,7 +131,7 @@
friend class TimingLogger;
};
- explicit TimingLogger(const char* name, bool precise, bool verbose);
+ TimingLogger(const char* name, bool precise, bool verbose);
~TimingLogger();
// Verify that all open timings have related closed timings.
void Verify();
@@ -156,7 +156,7 @@
// starts and ends.
class ScopedTiming {
public:
- explicit ScopedTiming(const char* label, TimingLogger* logger) : logger_(logger) {
+ ScopedTiming(const char* label, TimingLogger* logger) : logger_(logger) {
logger_->StartTiming(label);
}
~ScopedTiming() {
diff --git a/runtime/base/unix_file/fd_file.h b/runtime/base/unix_file/fd_file.h
index d51fbd6..f47368b 100644
--- a/runtime/base/unix_file/fd_file.h
+++ b/runtime/base/unix_file/fd_file.h
@@ -35,8 +35,8 @@
FdFile();
// Creates an FdFile using the given file descriptor. Takes ownership of the
// file descriptor. (Use DisableAutoClose to retain ownership.)
- explicit FdFile(int fd, bool checkUsage);
- explicit FdFile(int fd, const std::string& path, bool checkUsage);
+ FdFile(int fd, bool checkUsage);
+ FdFile(int fd, const std::string& path, bool checkUsage);
// Destroys an FdFile, closing the file descriptor if Close hasn't already
// been called. (If you care about the return value of Close, call it
diff --git a/runtime/check_jni.cc b/runtime/check_jni.cc
index 38bc818..4172b89 100644
--- a/runtime/check_jni.cc
+++ b/runtime/check_jni.cc
@@ -130,7 +130,7 @@
class ScopedCheck {
public:
- explicit ScopedCheck(int flags, const char* functionName, bool has_method = true)
+ ScopedCheck(int flags, const char* functionName, bool has_method = true)
: function_name_(functionName), flags_(flags), indent_(0), has_method_(has_method) {
}
diff --git a/runtime/debugger.cc b/runtime/debugger.cc
index 8e60814..dfb7f63 100644
--- a/runtime/debugger.cc
+++ b/runtime/debugger.cc
@@ -3588,10 +3588,10 @@
// Find the dex_pc values that correspond to the current line, for line-based single-stepping.
struct DebugCallbackContext {
- explicit DebugCallbackContext(SingleStepControl* single_step_control_cb,
- int32_t line_number_cb, const DexFile::CodeItem* code_item)
- : single_step_control_(single_step_control_cb), line_number_(line_number_cb),
- code_item_(code_item), last_pc_valid(false), last_pc(0) {
+ DebugCallbackContext(SingleStepControl* single_step_control_cb,
+ int32_t line_number_cb, const DexFile::CodeItem* code_item)
+ : single_step_control_(single_step_control_cb), line_number_(line_number_cb),
+ code_item_(code_item), last_pc_valid(false), last_pc(0) {
}
static bool Callback(void* raw_context, uint32_t address, uint32_t line_number_cb) {
diff --git a/runtime/gc/accounting/mod_union_table.cc b/runtime/gc/accounting/mod_union_table.cc
index b9e8925..b5ab3d9 100644
--- a/runtime/gc/accounting/mod_union_table.cc
+++ b/runtime/gc/accounting/mod_union_table.cc
@@ -54,8 +54,7 @@
class ModUnionAddToCardBitmapVisitor {
public:
- explicit ModUnionAddToCardBitmapVisitor(ModUnionTable::CardBitmap* bitmap,
- CardTable* card_table)
+ ModUnionAddToCardBitmapVisitor(ModUnionTable::CardBitmap* bitmap, CardTable* card_table)
: bitmap_(bitmap), card_table_(card_table) {
}
@@ -175,9 +174,9 @@
class AddToReferenceArrayVisitor {
public:
- explicit AddToReferenceArrayVisitor(ModUnionTableReferenceCache* mod_union_table,
- std::vector<mirror::HeapReference<Object>*>* references)
- : mod_union_table_(mod_union_table), references_(references) {
+ AddToReferenceArrayVisitor(ModUnionTableReferenceCache* mod_union_table,
+ std::vector<mirror::HeapReference<Object>*>* references)
+ : mod_union_table_(mod_union_table), references_(references) {
}
// Extra parameters are required since we use this same visitor signature for checking objects.
@@ -211,10 +210,10 @@
class ModUnionReferenceVisitor {
public:
- explicit ModUnionReferenceVisitor(ModUnionTableReferenceCache* const mod_union_table,
- std::vector<mirror::HeapReference<Object>*>* references)
- : mod_union_table_(mod_union_table),
- references_(references) {
+ ModUnionReferenceVisitor(ModUnionTableReferenceCache* const mod_union_table,
+ std::vector<mirror::HeapReference<Object>*>* references)
+ : mod_union_table_(mod_union_table),
+ references_(references) {
}
void operator()(Object* obj) const
@@ -231,10 +230,10 @@
class CheckReferenceVisitor {
public:
- explicit CheckReferenceVisitor(ModUnionTableReferenceCache* mod_union_table,
- const std::set<const Object*>& references)
- : mod_union_table_(mod_union_table),
- references_(references) {
+ CheckReferenceVisitor(ModUnionTableReferenceCache* mod_union_table,
+ const std::set<const Object*>& references)
+ : mod_union_table_(mod_union_table),
+ references_(references) {
}
// Extra parameters are required since we use this same visitor signature for checking objects.
@@ -277,8 +276,8 @@
class ModUnionCheckReferences {
public:
- explicit ModUnionCheckReferences(ModUnionTableReferenceCache* mod_union_table,
- const std::set<const Object*>& references)
+ ModUnionCheckReferences(ModUnionTableReferenceCache* mod_union_table,
+ const std::set<const Object*>& references)
REQUIRES(Locks::heap_bitmap_lock_)
: mod_union_table_(mod_union_table), references_(references) {
}
diff --git a/runtime/gc/collector/concurrent_copying.cc b/runtime/gc/collector/concurrent_copying.cc
index 8e329d6..220c06e 100644
--- a/runtime/gc/collector/concurrent_copying.cc
+++ b/runtime/gc/collector/concurrent_copying.cc
@@ -181,7 +181,7 @@
// Used to switch the thread roots of a thread from from-space refs to to-space refs.
class ThreadFlipVisitor : public Closure {
public:
- explicit ThreadFlipVisitor(ConcurrentCopying* concurrent_copying, bool use_tlab)
+ ThreadFlipVisitor(ConcurrentCopying* concurrent_copying, bool use_tlab)
: concurrent_copying_(concurrent_copying), use_tlab_(use_tlab) {
}
@@ -817,8 +817,8 @@
class RevokeThreadLocalMarkStackCheckpoint : public Closure {
public:
- explicit RevokeThreadLocalMarkStackCheckpoint(ConcurrentCopying* concurrent_copying,
- bool disable_weak_ref_access)
+ RevokeThreadLocalMarkStackCheckpoint(ConcurrentCopying* concurrent_copying,
+ bool disable_weak_ref_access)
: concurrent_copying_(concurrent_copying),
disable_weak_ref_access_(disable_weak_ref_access) {
}
diff --git a/runtime/gc/collector/mark_sweep.cc b/runtime/gc/collector/mark_sweep.cc
index 5799b66..b0a8a5b 100644
--- a/runtime/gc/collector/mark_sweep.cc
+++ b/runtime/gc/collector/mark_sweep.cc
@@ -648,8 +648,8 @@
protected:
class MarkObjectParallelVisitor {
public:
- ALWAYS_INLINE explicit MarkObjectParallelVisitor(MarkStackTask<kUseFinger>* chunk_task,
- MarkSweep* mark_sweep)
+ ALWAYS_INLINE MarkObjectParallelVisitor(MarkStackTask<kUseFinger>* chunk_task,
+ MarkSweep* mark_sweep)
: chunk_task_(chunk_task), mark_sweep_(mark_sweep) {}
void operator()(mirror::Object* obj, MemberOffset offset, bool /* static */) const
@@ -1058,8 +1058,8 @@
class CheckpointMarkThreadRoots : public Closure, public RootVisitor {
public:
- explicit CheckpointMarkThreadRoots(MarkSweep* mark_sweep,
- bool revoke_ros_alloc_thread_local_buffers_at_checkpoint)
+ CheckpointMarkThreadRoots(MarkSweep* mark_sweep,
+ bool revoke_ros_alloc_thread_local_buffers_at_checkpoint)
: mark_sweep_(mark_sweep),
revoke_ros_alloc_thread_local_buffers_at_checkpoint_(
revoke_ros_alloc_thread_local_buffers_at_checkpoint) {
diff --git a/runtime/gc/collector/mark_sweep.h b/runtime/gc/collector/mark_sweep.h
index 606be63..8bd1dc7 100644
--- a/runtime/gc/collector/mark_sweep.h
+++ b/runtime/gc/collector/mark_sweep.h
@@ -54,7 +54,7 @@
class MarkSweep : public GarbageCollector {
public:
- explicit MarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
+ MarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
~MarkSweep() {}
diff --git a/runtime/gc/collector/partial_mark_sweep.h b/runtime/gc/collector/partial_mark_sweep.h
index 7b69bce..e9b4f6f 100644
--- a/runtime/gc/collector/partial_mark_sweep.h
+++ b/runtime/gc/collector/partial_mark_sweep.h
@@ -30,7 +30,7 @@
return kGcTypePartial;
}
- explicit PartialMarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
+ PartialMarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
~PartialMarkSweep() {}
protected:
diff --git a/runtime/gc/collector/sticky_mark_sweep.h b/runtime/gc/collector/sticky_mark_sweep.h
index e8e70de..e8f0672 100644
--- a/runtime/gc/collector/sticky_mark_sweep.h
+++ b/runtime/gc/collector/sticky_mark_sweep.h
@@ -30,7 +30,7 @@
return kGcTypeSticky;
}
- explicit StickyMarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
+ StickyMarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
~StickyMarkSweep() {}
protected:
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index 1033d71..e56351f 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -2100,7 +2100,7 @@
// Special compacting collector which uses sub-optimal bin packing to reduce zygote space size.
class ZygoteCompactingCollector FINAL : public collector::SemiSpace {
public:
- explicit ZygoteCompactingCollector(gc::Heap* heap, bool is_running_on_memory_tool)
+ ZygoteCompactingCollector(gc::Heap* heap, bool is_running_on_memory_tool)
: SemiSpace(heap, false, "zygote collector"),
bin_live_bitmap_(nullptr),
bin_mark_bitmap_(nullptr),
@@ -2629,7 +2629,7 @@
// Verify a reference from an object.
class VerifyReferenceVisitor : public SingleRootVisitor {
public:
- explicit VerifyReferenceVisitor(Heap* heap, Atomic<size_t>* fail_count, bool verify_referent)
+ VerifyReferenceVisitor(Heap* heap, Atomic<size_t>* fail_count, bool verify_referent)
SHARED_REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_)
: heap_(heap), fail_count_(fail_count), verify_referent_(verify_referent) {}
@@ -2779,7 +2779,7 @@
// Verify all references within an object, for use with HeapBitmap::Visit.
class VerifyObjectVisitor {
public:
- explicit VerifyObjectVisitor(Heap* heap, Atomic<size_t>* fail_count, bool verify_referent)
+ VerifyObjectVisitor(Heap* heap, Atomic<size_t>* fail_count, bool verify_referent)
: heap_(heap), fail_count_(fail_count), verify_referent_(verify_referent) {}
void operator()(mirror::Object* obj)
@@ -3448,8 +3448,8 @@
class Heap::ConcurrentGCTask : public HeapTask {
public:
- explicit ConcurrentGCTask(uint64_t target_time, bool force_full)
- : HeapTask(target_time), force_full_(force_full) { }
+ ConcurrentGCTask(uint64_t target_time, bool force_full)
+ : HeapTask(target_time), force_full_(force_full) { }
virtual void Run(Thread* self) OVERRIDE {
gc::Heap* heap = Runtime::Current()->GetHeap();
heap->ConcurrentGC(self, force_full_);
diff --git a/runtime/gc/heap.h b/runtime/gc/heap.h
index 283a3cb..d94f109 100644
--- a/runtime/gc/heap.h
+++ b/runtime/gc/heap.h
@@ -160,36 +160,36 @@
// Create a heap with the requested sizes. The possible empty
// image_file_names names specify Spaces to load based on
// ImageWriter output.
- explicit Heap(size_t initial_size,
- size_t growth_limit,
- size_t min_free,
- size_t max_free,
- double target_utilization,
- double foreground_heap_growth_multiplier,
- size_t capacity,
- size_t non_moving_space_capacity,
- const std::string& original_image_file_name,
- InstructionSet image_instruction_set,
- CollectorType foreground_collector_type,
- CollectorType background_collector_type,
- space::LargeObjectSpaceType large_object_space_type,
- size_t large_object_threshold,
- size_t parallel_gc_threads,
- size_t conc_gc_threads,
- bool low_memory_mode,
- size_t long_pause_threshold,
- size_t long_gc_threshold,
- bool ignore_max_footprint,
- bool use_tlab,
- bool verify_pre_gc_heap,
- bool verify_pre_sweeping_heap,
- bool verify_post_gc_heap,
- bool verify_pre_gc_rosalloc,
- bool verify_pre_sweeping_rosalloc,
- bool verify_post_gc_rosalloc,
- bool gc_stress_mode,
- bool use_homogeneous_space_compaction,
- uint64_t min_interval_homogeneous_space_compaction_by_oom);
+ Heap(size_t initial_size,
+ size_t growth_limit,
+ size_t min_free,
+ size_t max_free,
+ double target_utilization,
+ double foreground_heap_growth_multiplier,
+ size_t capacity,
+ size_t non_moving_space_capacity,
+ const std::string& original_image_file_name,
+ InstructionSet image_instruction_set,
+ CollectorType foreground_collector_type,
+ CollectorType background_collector_type,
+ space::LargeObjectSpaceType large_object_space_type,
+ size_t large_object_threshold,
+ size_t parallel_gc_threads,
+ size_t conc_gc_threads,
+ bool low_memory_mode,
+ size_t long_pause_threshold,
+ size_t long_gc_threshold,
+ bool ignore_max_footprint,
+ bool use_tlab,
+ bool verify_pre_gc_heap,
+ bool verify_pre_sweeping_heap,
+ bool verify_post_gc_heap,
+ bool verify_pre_gc_rosalloc,
+ bool verify_pre_sweeping_rosalloc,
+ bool verify_post_gc_rosalloc,
+ bool gc_stress_mode,
+ bool use_homogeneous_space_compaction,
+ uint64_t min_interval_homogeneous_space_compaction_by_oom);
~Heap();
diff --git a/runtime/gc/space/memory_tool_malloc_space.h b/runtime/gc/space/memory_tool_malloc_space.h
index fe39e05..a5dbad9 100644
--- a/runtime/gc/space/memory_tool_malloc_space.h
+++ b/runtime/gc/space/memory_tool_malloc_space.h
@@ -55,7 +55,7 @@
size_t MaxBytesBulkAllocatedFor(size_t num_bytes) OVERRIDE;
template <typename... Params>
- explicit MemoryToolMallocSpace(MemMap* mem_map, size_t initial_size, Params... params);
+ MemoryToolMallocSpace(MemMap* mem_map, size_t initial_size, Params... params);
virtual ~MemoryToolMallocSpace() {}
private:
diff --git a/runtime/gc/task_processor_test.cc b/runtime/gc/task_processor_test.cc
index f06f68d..2c44da2 100644
--- a/runtime/gc/task_processor_test.cc
+++ b/runtime/gc/task_processor_test.cc
@@ -102,7 +102,7 @@
class TestOrderTask : public HeapTask {
public:
- explicit TestOrderTask(uint64_t expected_time, size_t expected_counter, size_t* counter)
+ TestOrderTask(uint64_t expected_time, size_t expected_counter, size_t* counter)
: HeapTask(expected_time), expected_counter_(expected_counter), counter_(counter) {
}
virtual void Run(Thread* thread) OVERRIDE {
diff --git a/runtime/handle_scope.h b/runtime/handle_scope.h
index 5ed8ef0..e617348 100644
--- a/runtime/handle_scope.h
+++ b/runtime/handle_scope.h
@@ -106,7 +106,7 @@
}
// Semi-hidden constructor. Construction expected by generated code and StackHandleScope.
- explicit HandleScope(HandleScope* link, uint32_t num_references) :
+ HandleScope(HandleScope* link, uint32_t num_references) :
link_(link), number_of_references_(num_references) {
}
diff --git a/runtime/indirect_reference_table.h b/runtime/indirect_reference_table.h
index 798b48c..c398555 100644
--- a/runtime/indirect_reference_table.h
+++ b/runtime/indirect_reference_table.h
@@ -227,8 +227,7 @@
class IrtIterator {
public:
- explicit IrtIterator(IrtEntry* table, size_t i, size_t capacity)
- SHARED_REQUIRES(Locks::mutator_lock_)
+ IrtIterator(IrtEntry* table, size_t i, size_t capacity) SHARED_REQUIRES(Locks::mutator_lock_)
: table_(table), i_(i), capacity_(capacity) {
}
diff --git a/runtime/jit/jit_instrumentation.cc b/runtime/jit/jit_instrumentation.cc
index 1e56cdc..258c29d 100644
--- a/runtime/jit/jit_instrumentation.cc
+++ b/runtime/jit/jit_instrumentation.cc
@@ -26,7 +26,7 @@
class JitCompileTask : public Task {
public:
- explicit JitCompileTask(ArtMethod* method, JitInstrumentationCache* cache)
+ JitCompileTask(ArtMethod* method, JitInstrumentationCache* cache)
: method_(method), cache_(cache) {
}
diff --git a/runtime/lock_word.h b/runtime/lock_word.h
index 245f8b8..5d0d204 100644
--- a/runtime/lock_word.h
+++ b/runtime/lock_word.h
@@ -197,7 +197,7 @@
size_t ForwardingAddress() const;
// Constructor a lock word for inflation to use a Monitor.
- explicit LockWord(Monitor* mon, uint32_t rb_state);
+ LockWord(Monitor* mon, uint32_t rb_state);
// Return the hash code stored in the lock word, must be kHashCode state.
int32_t GetHashCode() const;
diff --git a/runtime/mirror/class.cc b/runtime/mirror/class.cc
index 6af90bb..f20cc6e 100644
--- a/runtime/mirror/class.cc
+++ b/runtime/mirror/class.cc
@@ -855,9 +855,9 @@
// The pre-fence visitor for Class::CopyOf().
class CopyClassVisitor {
public:
- explicit CopyClassVisitor(Thread* self, Handle<mirror::Class>* orig, size_t new_length,
- size_t copy_bytes, ArtMethod* const (&imt)[mirror::Class::kImtSize],
- size_t pointer_size)
+ CopyClassVisitor(Thread* self, Handle<mirror::Class>* orig, size_t new_length,
+ size_t copy_bytes, ArtMethod* const (&imt)[mirror::Class::kImtSize],
+ size_t pointer_size)
: self_(self), orig_(orig), new_length_(new_length),
copy_bytes_(copy_bytes), imt_(imt), pointer_size_(pointer_size) {
}
diff --git a/runtime/mirror/object.cc b/runtime/mirror/object.cc
index 87fb5ba..df680b5 100644
--- a/runtime/mirror/object.cc
+++ b/runtime/mirror/object.cc
@@ -107,7 +107,7 @@
// An allocation pre-fence visitor that copies the object.
class CopyObjectVisitor {
public:
- explicit CopyObjectVisitor(Thread* self, Handle<Object>* orig, size_t num_bytes)
+ CopyObjectVisitor(Thread* self, Handle<Object>* orig, size_t num_bytes)
: self_(self), orig_(orig), num_bytes_(num_bytes) {
}
diff --git a/runtime/monitor.h b/runtime/monitor.h
index 3ca8954..346e866 100644
--- a/runtime/monitor.h
+++ b/runtime/monitor.h
@@ -151,10 +151,10 @@
#endif
private:
- explicit Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code)
- SHARED_REQUIRES(Locks::mutator_lock_);
- explicit Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code,
- MonitorId id) SHARED_REQUIRES(Locks::mutator_lock_);
+ Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code)
+ SHARED_REQUIRES(Locks::mutator_lock_);
+ Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code, MonitorId id)
+ SHARED_REQUIRES(Locks::mutator_lock_);
// Install the monitor into its object, may fail if another thread installs a different monitor
// first.
diff --git a/runtime/monitor_test.cc b/runtime/monitor_test.cc
index 1be637c..e1173bb 100644
--- a/runtime/monitor_test.cc
+++ b/runtime/monitor_test.cc
@@ -106,8 +106,7 @@
class CreateTask : public Task {
public:
- explicit CreateTask(MonitorTest* monitor_test, uint64_t initial_sleep, int64_t millis,
- bool expected) :
+ CreateTask(MonitorTest* monitor_test, uint64_t initial_sleep, int64_t millis, bool expected) :
monitor_test_(monitor_test), initial_sleep_(initial_sleep), millis_(millis),
expected_(expected) {}
diff --git a/runtime/reflection.cc b/runtime/reflection.cc
index 100d199..2fe1e64 100644
--- a/runtime/reflection.cc
+++ b/runtime/reflection.cc
@@ -36,7 +36,7 @@
class ArgArray {
public:
- explicit ArgArray(const char* shorty, uint32_t shorty_len)
+ ArgArray(const char* shorty, uint32_t shorty_len)
: shorty_(shorty), shorty_len_(shorty_len), num_bytes_(0) {
size_t num_slots = shorty_len + 1; // +1 in case of receiver.
if (LIKELY((num_slots * 2) < kSmallArgArraySize)) {
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 74e3f11..d54a7a6 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -1808,7 +1808,7 @@
template<bool kTransactionActive>
class BuildInternalStackTraceVisitor : public StackVisitor {
public:
- explicit BuildInternalStackTraceVisitor(Thread* self, Thread* thread, int skip_depth)
+ BuildInternalStackTraceVisitor(Thread* self, Thread* thread, int skip_depth)
: StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
self_(self),
skip_depth_(skip_depth),
diff --git a/runtime/thread_pool.h b/runtime/thread_pool.h
index 1ca0a21..a2338d6 100644
--- a/runtime/thread_pool.h
+++ b/runtime/thread_pool.h
@@ -91,7 +91,7 @@
// after running it, it is the caller's responsibility.
void AddTask(Thread* self, Task* task) REQUIRES(!task_queue_lock_);
- explicit ThreadPool(const char* name, size_t num_threads);
+ ThreadPool(const char* name, size_t num_threads);
virtual ~ThreadPool();
// Wait for all tasks currently on queue to get completed.