From f0f56b02134c8478011fcd22aac65180daf53601 Mon Sep 17 00:00:00 2001 From: Augusto Caringi Date: Wed, 6 Feb 2019 18:25:58 +0100 Subject: [PATCH] Re-enable subset of build warnings and fix some related warnings #316 --- CMakeLists.txt | 16 ++-- src/ast/codegen_llvm.cpp | 8 +- src/ast/irbuilderbpf.cpp | 2 +- src/ast/semantic_analyser.cpp | 6 +- src/ast/semantic_analyser.h | 4 +- src/bpftrace.cpp | 4 +- src/bpftrace.h | 2 +- src/mapkey.cpp | 2 +- src/utils-inl.h | 2 +- tests/bpftrace.cpp | 76 +++++++++--------- tests/clang_parser.cpp | 140 +++++++++++++++++----------------- tests/codegen/general.cpp | 14 ++-- 12 files changed, 138 insertions(+), 138 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 3adb20d901b..5a490bfac3a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -7,19 +7,19 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) add_compile_options("-std=c++14") add_compile_options("-Wno-format-security") #add_compile_options("-Wall") -#add_compile_options("-Wextra") -#add_compile_options("-Wundef") -#add_compile_options("-Wpointer-arith") -#add_compile_options("-Wcast-align") -#add_compile_options("-Wwrite-strings") +add_compile_options("-Wextra") +add_compile_options("-Wundef") +add_compile_options("-Wpointer-arith") +add_compile_options("-Wcast-align") +add_compile_options("-Wwrite-strings") #add_compile_options("-Wcast-qual") #add_compile_options("-Wswitch-default") #add_compile_options("-Wswitch-enum") #add_compile_options("-Wconversion") -#add_compile_options("-Wunreachable-code") +add_compile_options("-Wunreachable-code") #add_compile_options("-Wformat=2") -#add_compile_options("-Wstrict-overflow=5") -#add_compile_options("-Wdisabled-optimization") +add_compile_options("-Wstrict-overflow=5") +add_compile_options("-Wdisabled-optimization") include(CTest) diff --git a/src/ast/codegen_llvm.cpp b/src/ast/codegen_llvm.cpp index 4c59abf1818..3136a23edf4 100644 --- a/src/ast/codegen_llvm.cpp +++ b/src/ast/codegen_llvm.cpp @@ -496,7 +496,7 @@ void CodegenLLVM::visit(Call &call) int struct_size = layout_.getTypeAllocSize(printf_struct); auto *struct_layout = layout_.getStructLayout(printf_struct); - for (int i=0; igetElementOffset(i+1); // +1 for the printf_id field @@ -506,7 +506,7 @@ void CodegenLLVM::visit(Call &call) b_.CreateMemSet(printf_args, b_.getInt8(0), struct_size, 1); b_.CreateStore(b_.getInt64(printf_id_), printf_args); - for (int i=1; isize(); i++) + for (size_t i=1; isize(); i++) { Expression &arg = *call.vargs->at(i); expr_deleter_ = nullptr; @@ -548,7 +548,7 @@ void CodegenLLVM::visit(Call &call) int struct_size = layout_.getTypeAllocSize(printf_struct); auto *struct_layout = layout_.getStructLayout(printf_struct); - for (int i=0; igetElementOffset(i+1); // +1 for the system_id field @@ -559,7 +559,7 @@ void CodegenLLVM::visit(Call &call) // system_id_ has an offset to avoid be confused with printf b_.CreateStore(b_.getInt64(system_id_ + asyncactionint(AsyncAction::syscall)), system_args); - for (int i=1; isize(); i++) + for (size_t i=1; isize(); i++) { Expression &arg = *call.vargs->at(i); expr_deleter_ = nullptr; diff --git a/src/ast/irbuilderbpf.cpp b/src/ast/irbuilderbpf.cpp index 4fb9646408d..1568f03b8d3 100644 --- a/src/ast/irbuilderbpf.cpp +++ b/src/ast/irbuilderbpf.cpp @@ -366,7 +366,7 @@ Value *IRBuilderBPF::CreateStrcmp(Value* val, std::string str, bool inverse) { CreateStore(getInt1(inverse), store); const char *c_str = str.c_str(); - for (int i = 0; i < strlen(c_str) + 1; i++) + for (size_t i = 0; i < strlen(c_str) + 1; i++) { BasicBlock *char_eq = BasicBlock::Create(module_.getContext(), "strcmp.loop", parent); AllocaInst *val_char = CreateAllocaBPF(getInt8Ty(), "strcmp.char"); diff --git a/src/ast/semantic_analyser.cpp b/src/ast/semantic_analyser.cpp index b9697a8c3f2..a1ed2d74b93 100644 --- a/src/ast/semantic_analyser.cpp +++ b/src/ast/semantic_analyser.cpp @@ -314,7 +314,7 @@ void SemanticAnalyser::visit(Call &call) // Promote to 64-bit if it's not an array type if (!ty.IsArray()) ty.size = 8; - args.push_back({ .type = ty }); + args.push_back({ .type = ty, .offset = 0 }); } err_ << verify_format_string(fmt.str, args); @@ -988,7 +988,7 @@ bool SemanticAnalyser::check_assignment(const Call &call, bool want_map, bool wa return true; } -bool SemanticAnalyser::check_nargs(const Call &call, int expected_nargs) +bool SemanticAnalyser::check_nargs(const Call &call, size_t expected_nargs) { std::vector::size_type nargs = 0; if (call.vargs) @@ -1003,7 +1003,7 @@ bool SemanticAnalyser::check_nargs(const Call &call, int expected_nargs) return true; } -bool SemanticAnalyser::check_varargs(const Call &call, int min_nargs, int max_nargs) +bool SemanticAnalyser::check_varargs(const Call &call, size_t min_nargs, size_t max_nargs) { std::vector::size_type nargs = 0; if (call.vargs) diff --git a/src/ast/semantic_analyser.h b/src/ast/semantic_analyser.h index 4fdf52fc9cb..e929bd02a94 100644 --- a/src/ast/semantic_analyser.h +++ b/src/ast/semantic_analyser.h @@ -55,8 +55,8 @@ class SemanticAnalyser : public Visitor { std::string get_cast_type(Expression *expr); bool check_assignment(const Call &call, bool want_map, bool want_var); - bool check_nargs(const Call &call, int expected_nargs); - bool check_varargs(const Call &call, int min_nargs, int max_nargs); + bool check_nargs(const Call &call, size_t expected_nargs); + bool check_varargs(const Call &call, size_t min_nargs, size_t max_nargs); bool check_arg(const Call &call, Type type, int arg_num, bool want_literal=false); bool check_alpha_numeric(const Call &call, int arg_num); diff --git a/src/bpftrace.cpp b/src/bpftrace.cpp index 8f221bcc144..6686bd40a3a 100644 --- a/src/bpftrace.cpp +++ b/src/bpftrace.cpp @@ -466,7 +466,7 @@ void BPFtrace::add_param(const std::string ¶m) params_.emplace_back(param); } -std::string BPFtrace::get_param(int i) +std::string BPFtrace::get_param(size_t i) { if (i > 0 && i < params_.size() + 1) return params_[i - 1]; @@ -868,7 +868,7 @@ int BPFtrace::print_map(IMap &map, uint32_t top, uint32_t div) if (div == 0) div = 1; uint32_t i = 0; - int total = values_by_key.size(); + size_t total = values_by_key.size(); for (auto &pair : values_by_key) { auto key = pair.first; diff --git a/src/bpftrace.h b/src/bpftrace.h index 7f6b6a00829..31174658b25 100644 --- a/src/bpftrace.h +++ b/src/bpftrace.h @@ -70,7 +70,7 @@ class BPFtrace std::vector> get_arg_values(const std::vector &args, uint8_t* arg_data); void add_param(const std::string ¶m); bool is_numeric(std::string str); - std::string get_param(int index); + std::string get_param(size_t index); std::string cmd_; int pid_{0}; diff --git a/src/mapkey.cpp b/src/mapkey.cpp index 34ac230ecde..743d138a5c1 100644 --- a/src/mapkey.cpp +++ b/src/mapkey.cpp @@ -69,8 +69,8 @@ std::string MapKey::argument_value(BPFtrace &bpftrace, return std::to_string(*(int32_t*)data); case 8: return std::to_string(*(int64_t*)data); - break; } + break; case Type::kstack: return bpftrace.get_stack(*(uint64_t*)data, false); case Type::ustack: diff --git a/src/utils-inl.h b/src/utils-inl.h index 02daa9a6a95..a329bf35592 100644 --- a/src/utils-inl.h +++ b/src/utils-inl.h @@ -1,7 +1,7 @@ namespace bpftrace { inline std::string GetProviderFromPath(std::string path) { - int i = path.rfind("/"); + size_t i = path.rfind("/"); return (i != std::string::npos) ? path.substr(i + 1) : path; } diff --git a/tests/bpftrace.cpp b/tests/bpftrace.cpp index c79a5f042db..a13b7405351 100644 --- a/tests/bpftrace.cpp +++ b/tests/bpftrace.cpp @@ -107,8 +107,8 @@ TEST(bpftrace, add_begin_probe) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(0, bpftrace.get_probes().size()); - EXPECT_EQ(1, bpftrace.get_special_probes().size()); + EXPECT_EQ(0U, bpftrace.get_probes().size()); + EXPECT_EQ(1U, bpftrace.get_special_probes().size()); check_special_probe(bpftrace.get_special_probes().at(0), "BEGIN_trigger", "BEGIN"); } @@ -121,8 +121,8 @@ TEST(bpftrace, add_end_probe) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(0, bpftrace.get_probes().size()); - EXPECT_EQ(1, bpftrace.get_special_probes().size()); + EXPECT_EQ(0U, bpftrace.get_probes().size()); + EXPECT_EQ(1U, bpftrace.get_special_probes().size()); check_special_probe(bpftrace.get_special_probes().at(0), "END_trigger", "END"); } @@ -135,8 +135,8 @@ TEST(bpftrace, add_probes_single) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(1, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(1U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); check_kprobe(bpftrace.get_probes().at(0), "sys_read", "kprobe:sys_read"); } @@ -150,8 +150,8 @@ TEST(bpftrace, add_probes_multiple) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(2, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(2U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); std::string probe_orig_name = "kprobe:sys_read,kprobe:sys_write"; check_kprobe(bpftrace.get_probes().at(0), "sys_read", probe_orig_name); @@ -175,8 +175,8 @@ TEST(bpftrace, add_probes_character_class) .Times(1); EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(3, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(3U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); std::string probe_orig_name = "kprobe:[Ss]y[Ss]_read,kprobe:sys_write"; check_kprobe(bpftrace.get_probes().at(0), "SyS_read", probe_orig_name); @@ -202,8 +202,8 @@ TEST(bpftrace, add_probes_wildcard) .Times(1); EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(4, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(4U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); std::string probe_orig_name = "kprobe:sys_read,kprobe:my_*,kprobe:sys_write"; check_kprobe(bpftrace.get_probes().at(0), "sys_read", probe_orig_name); @@ -230,8 +230,8 @@ TEST(bpftrace, add_probes_wildcard_no_matches) .Times(1); EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(2, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(2U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); std::string probe_orig_name = "kprobe:sys_read,kprobe:my_*,kprobe:sys_write"; check_kprobe(bpftrace.get_probes().at(0), "sys_read", probe_orig_name); @@ -247,8 +247,8 @@ TEST(bpftrace, add_probes_uprobe) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(1, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(1U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); check_uprobe(bpftrace.get_probes().at(0), "/bin/sh", "foo", "uprobe:/bin/sh:foo"); } @@ -261,8 +261,8 @@ TEST(bpftrace, add_probes_usdt) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(1, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(1U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); check_usdt(bpftrace.get_probes().at(0), "/bin/sh", "foo", "usdt:/bin/sh:foo"); } @@ -275,8 +275,8 @@ TEST(bpftrace, add_probes_uprobe_wildcard) StrictMock bpftrace; EXPECT_EQ(bpftrace.add_probe(probe), 0); - EXPECT_EQ(1, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(1U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); } TEST(bpftrace, add_probes_uprobe_wildcard_no_matches) @@ -288,8 +288,8 @@ TEST(bpftrace, add_probes_uprobe_wildcard_no_matches) StrictMock bpftrace; EXPECT_EQ(bpftrace.add_probe(probe), 0); - EXPECT_EQ(0, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(0U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); } TEST(bpftrace, add_probes_uprobe_string_literal) @@ -301,8 +301,8 @@ TEST(bpftrace, add_probes_uprobe_string_literal) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(1, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(1U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); check_uprobe(bpftrace.get_probes().at(0), "/bin/sh", "foo*", "uprobe:/bin/sh:foo*"); } @@ -315,8 +315,8 @@ TEST(bpftrace, add_probes_tracepoint) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(1, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(1U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); std::string probe_orig_name = "tracepoint:sched:sched_switch"; check_tracepoint(bpftrace.get_probes().at(0), "sched", "sched_switch", probe_orig_name); @@ -338,8 +338,8 @@ TEST(bpftrace, add_probes_tracepoint_wildcard) .Times(1); EXPECT_EQ(bpftrace.add_probe(probe), 0); - EXPECT_EQ(2, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(2U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); std::string probe_orig_name = "tracepoint:sched:sched_*"; check_tracepoint(bpftrace.get_probes().at(0), "sched", "sched_one", probe_orig_name); @@ -362,8 +362,8 @@ TEST(bpftrace, add_probes_tracepoint_wildcard_no_matches) .Times(1); EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(0, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(0U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); } TEST(bpftrace, add_probes_profile) @@ -375,8 +375,8 @@ TEST(bpftrace, add_probes_profile) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(1, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(1U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); std::string probe_orig_name = "profile:ms:997"; check_profile(bpftrace.get_probes().at(0), "ms", 997, probe_orig_name); @@ -391,8 +391,8 @@ TEST(bpftrace, add_probes_interval) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(1, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(1U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); std::string probe_orig_name = "interval:s:1"; check_interval(bpftrace.get_probes().at(0), "s", 1, probe_orig_name); @@ -407,8 +407,8 @@ TEST(bpftrace, add_probes_software) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(1, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(1U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); std::string probe_orig_name = "software:faults:1000"; check_software(bpftrace.get_probes().at(0), "faults", 1000, probe_orig_name); @@ -423,8 +423,8 @@ TEST(bpftrace, add_probes_hardware) StrictMock bpftrace; EXPECT_EQ(0, bpftrace.add_probe(probe)); - EXPECT_EQ(1, bpftrace.get_probes().size()); - EXPECT_EQ(0, bpftrace.get_special_probes().size()); + EXPECT_EQ(1U, bpftrace.get_probes().size()); + EXPECT_EQ(0U, bpftrace.get_special_probes().size()); std::string probe_orig_name = "hardware:cache-references:1000000"; check_hardware(bpftrace.get_probes().at(0), "cache-references", 1000000, probe_orig_name); diff --git a/tests/clang_parser.cpp b/tests/clang_parser.cpp index e748b778cd8..f12a5e43061 100644 --- a/tests/clang_parser.cpp +++ b/tests/clang_parser.cpp @@ -21,25 +21,25 @@ TEST(clang_parser, integers) StructMap structs; parse("struct Foo { int x; int y, z; }", structs); - ASSERT_EQ(structs.size(), 1); - ASSERT_EQ(structs.count("Foo"), 1); + ASSERT_EQ(structs.size(), 1U); + ASSERT_EQ(structs.count("Foo"), 1U); EXPECT_EQ(structs["Foo"].size, 12); - ASSERT_EQ(structs["Foo"].fields.size(), 3); - ASSERT_EQ(structs["Foo"].fields.count("x"), 1); - ASSERT_EQ(structs["Foo"].fields.count("y"), 1); - ASSERT_EQ(structs["Foo"].fields.count("z"), 1); + ASSERT_EQ(structs["Foo"].fields.size(), 3U); + ASSERT_EQ(structs["Foo"].fields.count("x"), 1U); + ASSERT_EQ(structs["Foo"].fields.count("y"), 1U); + ASSERT_EQ(structs["Foo"].fields.count("z"), 1U); EXPECT_EQ(structs["Foo"].fields["x"].type.type, Type::integer); - EXPECT_EQ(structs["Foo"].fields["x"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["x"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["x"].offset, 0); EXPECT_EQ(structs["Foo"].fields["y"].type.type, Type::integer); - EXPECT_EQ(structs["Foo"].fields["y"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["y"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["y"].offset, 4); EXPECT_EQ(structs["Foo"].fields["z"].type.type, Type::integer); - EXPECT_EQ(structs["Foo"].fields["z"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["z"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["z"].offset, 8); } @@ -48,30 +48,30 @@ TEST(clang_parser, c_union) StructMap structs; parse("union Foo { char c; short s; int i; long l; }", structs); - ASSERT_EQ(structs.size(), 1); - ASSERT_EQ(structs.count("Foo"), 1); + ASSERT_EQ(structs.size(), 1U); + ASSERT_EQ(structs.count("Foo"), 1U); EXPECT_EQ(structs["Foo"].size, 8); - ASSERT_EQ(structs["Foo"].fields.size(), 4); - ASSERT_EQ(structs["Foo"].fields.count("c"), 1); - ASSERT_EQ(structs["Foo"].fields.count("s"), 1); - ASSERT_EQ(structs["Foo"].fields.count("i"), 1); - ASSERT_EQ(structs["Foo"].fields.count("l"), 1); + ASSERT_EQ(structs["Foo"].fields.size(), 4U); + ASSERT_EQ(structs["Foo"].fields.count("c"), 1U); + ASSERT_EQ(structs["Foo"].fields.count("s"), 1U); + ASSERT_EQ(structs["Foo"].fields.count("i"), 1U); + ASSERT_EQ(structs["Foo"].fields.count("l"), 1U); EXPECT_EQ(structs["Foo"].fields["c"].type.type, Type::integer); - EXPECT_EQ(structs["Foo"].fields["c"].type.size, 1); + EXPECT_EQ(structs["Foo"].fields["c"].type.size, 1U); EXPECT_EQ(structs["Foo"].fields["c"].offset, 0); EXPECT_EQ(structs["Foo"].fields["s"].type.type, Type::integer); - EXPECT_EQ(structs["Foo"].fields["s"].type.size, 2); + EXPECT_EQ(structs["Foo"].fields["s"].type.size, 2U); EXPECT_EQ(structs["Foo"].fields["s"].offset, 0); EXPECT_EQ(structs["Foo"].fields["i"].type.type, Type::integer); - EXPECT_EQ(structs["Foo"].fields["i"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["i"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["i"].offset, 0); EXPECT_EQ(structs["Foo"].fields["l"].type.type, Type::integer); - EXPECT_EQ(structs["Foo"].fields["l"].type.size, 8); + EXPECT_EQ(structs["Foo"].fields["l"].type.size, 8U); EXPECT_EQ(structs["Foo"].fields["l"].offset, 0); } @@ -80,12 +80,12 @@ TEST(clang_parser, integer_ptr) StructMap structs; parse("struct Foo { int *x; }", structs); - ASSERT_EQ(structs.size(), 1); - ASSERT_EQ(structs.count("Foo"), 1); + ASSERT_EQ(structs.size(), 1U); + ASSERT_EQ(structs.count("Foo"), 1U); EXPECT_EQ(structs["Foo"].size, 8); - ASSERT_EQ(structs["Foo"].fields.size(), 1); - ASSERT_EQ(structs["Foo"].fields.count("x"), 1); + ASSERT_EQ(structs["Foo"].fields.size(), 1U); + ASSERT_EQ(structs["Foo"].fields.count("x"), 1U); EXPECT_EQ(structs["Foo"].fields["x"].type.type, Type::integer); EXPECT_EQ(structs["Foo"].fields["x"].type.size, sizeof(uintptr_t)); @@ -99,17 +99,17 @@ TEST(clang_parser, string_ptr) StructMap structs; parse("struct Foo { char *str; }", structs); - ASSERT_EQ(structs.size(), 1); - ASSERT_EQ(structs.count("Foo"), 1); + ASSERT_EQ(structs.size(), 1U); + ASSERT_EQ(structs.count("Foo"), 1U); EXPECT_EQ(structs["Foo"].size, 8); - ASSERT_EQ(structs["Foo"].fields.size(), 1); - ASSERT_EQ(structs["Foo"].fields.count("str"), 1); + ASSERT_EQ(structs["Foo"].fields.size(), 1U); + ASSERT_EQ(structs["Foo"].fields.count("str"), 1U); EXPECT_EQ(structs["Foo"].fields["str"].type.type, Type::integer); EXPECT_EQ(structs["Foo"].fields["str"].type.size, sizeof(uintptr_t)); EXPECT_EQ(structs["Foo"].fields["str"].type.is_pointer, true); - EXPECT_EQ(structs["Foo"].fields["str"].type.pointee_size, 1); + EXPECT_EQ(structs["Foo"].fields["str"].type.pointee_size, 1U); EXPECT_EQ(structs["Foo"].fields["str"].offset, 0); } @@ -118,15 +118,15 @@ TEST(clang_parser, string_array) StructMap structs; parse("struct Foo { char str[32]; }", structs); - ASSERT_EQ(structs.size(), 1); - ASSERT_EQ(structs.count("Foo"), 1); + ASSERT_EQ(structs.size(), 1U); + ASSERT_EQ(structs.count("Foo"), 1U); EXPECT_EQ(structs["Foo"].size, 32); - ASSERT_EQ(structs["Foo"].fields.size(), 1); - ASSERT_EQ(structs["Foo"].fields.count("str"), 1); + ASSERT_EQ(structs["Foo"].fields.size(), 1U); + ASSERT_EQ(structs["Foo"].fields.count("str"), 1U); EXPECT_EQ(structs["Foo"].fields["str"].type.type, Type::string); - EXPECT_EQ(structs["Foo"].fields["str"].type.size, 32); + EXPECT_EQ(structs["Foo"].fields["str"].type.size, 32U); EXPECT_EQ(structs["Foo"].fields["str"].offset, 0); } @@ -135,17 +135,17 @@ TEST(clang_parser, nested_struct_named) StructMap structs; parse("struct Bar { int x; } struct Foo { struct Bar bar; }", structs); - ASSERT_EQ(structs.size(), 2); - ASSERT_EQ(structs.count("Foo"), 1); - ASSERT_EQ(structs.count("Bar"), 1); + ASSERT_EQ(structs.size(), 2U); + ASSERT_EQ(structs.count("Foo"), 1U); + ASSERT_EQ(structs.count("Bar"), 1U); EXPECT_EQ(structs["Foo"].size, 4); - ASSERT_EQ(structs["Foo"].fields.size(), 1); - ASSERT_EQ(structs["Foo"].fields.count("bar"), 1); + ASSERT_EQ(structs["Foo"].fields.size(), 1U); + ASSERT_EQ(structs["Foo"].fields.count("bar"), 1U); EXPECT_EQ(structs["Foo"].fields["bar"].type.type, Type::cast); EXPECT_EQ(structs["Foo"].fields["bar"].type.cast_type, "Bar"); - EXPECT_EQ(structs["Foo"].fields["bar"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["bar"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["bar"].offset, 0); } @@ -154,19 +154,19 @@ TEST(clang_parser, nested_struct_ptr_named) StructMap structs; parse("struct Bar { int x; } struct Foo { struct Bar *bar; }", structs); - ASSERT_EQ(structs.size(), 2); - ASSERT_EQ(structs.count("Foo"), 1); - ASSERT_EQ(structs.count("Bar"), 1); + ASSERT_EQ(structs.size(), 2U); + ASSERT_EQ(structs.count("Foo"), 1U); + ASSERT_EQ(structs.count("Bar"), 1U); EXPECT_EQ(structs["Foo"].size, 8); - ASSERT_EQ(structs["Foo"].fields.size(), 1); - ASSERT_EQ(structs["Foo"].fields.count("bar"), 1); + ASSERT_EQ(structs["Foo"].fields.size(), 1U); + ASSERT_EQ(structs["Foo"].fields.count("bar"), 1U); EXPECT_EQ(structs["Foo"].fields["bar"].type.type, Type::cast); EXPECT_EQ(structs["Foo"].fields["bar"].type.cast_type, "Bar"); EXPECT_EQ(structs["Foo"].fields["bar"].type.size, sizeof(uintptr_t)); EXPECT_EQ(structs["Foo"].fields["bar"].type.is_pointer, true); - EXPECT_EQ(structs["Foo"].fields["bar"].type.pointee_size, 4); + EXPECT_EQ(structs["Foo"].fields["bar"].type.pointee_size, 4U); EXPECT_EQ(structs["Foo"].fields["bar"].offset, 0); } @@ -175,16 +175,16 @@ TEST(clang_parser, nested_struct_anon) StructMap structs; parse("struct Foo { struct { int x; } bar; }", structs); - ASSERT_EQ(structs.size(), 2); - ASSERT_EQ(structs.count("Foo"), 1); + ASSERT_EQ(structs.size(), 2U); + ASSERT_EQ(structs.count("Foo"), 1U); EXPECT_EQ(structs["Foo"].size, 4); - ASSERT_EQ(structs["Foo"].fields.size(), 1); - ASSERT_EQ(structs["Foo"].fields.count("bar"), 1); + ASSERT_EQ(structs["Foo"].fields.size(), 1U); + ASSERT_EQ(structs["Foo"].fields.count("bar"), 1U); EXPECT_EQ(structs["Foo"].fields["bar"].type.type, Type::cast); EXPECT_EQ(structs["Foo"].fields["bar"].type.cast_type, "Foo::(anonymous at definitions.h:1:14)"); - EXPECT_EQ(structs["Foo"].fields["bar"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["bar"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["bar"].offset, 0); } @@ -193,15 +193,15 @@ TEST(clang_parser, nested_struct_indirect_fields) StructMap structs; parse("struct Foo { struct { int x; int y;}; int a; struct { int z; }; }", structs); - ASSERT_EQ(structs["Foo"].fields.size(), 4); + ASSERT_EQ(structs["Foo"].fields.size(), 4U); EXPECT_EQ(structs["Foo"].fields["x"].offset, 0); - EXPECT_EQ(structs["Foo"].fields["x"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["x"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["y"].offset, 4); - EXPECT_EQ(structs["Foo"].fields["y"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["y"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["a"].offset, 8); - EXPECT_EQ(structs["Foo"].fields["a"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["a"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["z"].offset, 12); - EXPECT_EQ(structs["Foo"].fields["z"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["z"].type.size, 4U); } TEST(clang_parser, nested_struct_anon_union_struct) @@ -209,17 +209,17 @@ TEST(clang_parser, nested_struct_anon_union_struct) StructMap structs; parse("struct Foo { union { long long _xy; struct { int x; int y;}; }; int a; struct { int z; }; }", structs); - ASSERT_EQ(structs["Foo"].fields.size(), 5); + ASSERT_EQ(structs["Foo"].fields.size(), 5U); EXPECT_EQ(structs["Foo"].fields["_xy"].offset, 0); - EXPECT_EQ(structs["Foo"].fields["_xy"].type.size, 8); + EXPECT_EQ(structs["Foo"].fields["_xy"].type.size, 8U); EXPECT_EQ(structs["Foo"].fields["x"].offset, 0); - EXPECT_EQ(structs["Foo"].fields["x"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["x"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["y"].offset, 4); - EXPECT_EQ(structs["Foo"].fields["y"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["y"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["a"].offset, 8); - EXPECT_EQ(structs["Foo"].fields["a"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["a"].type.size, 4U); EXPECT_EQ(structs["Foo"].fields["z"].offset, 12); - EXPECT_EQ(structs["Foo"].fields["z"].type.size, 4); + EXPECT_EQ(structs["Foo"].fields["z"].type.size, 4U); } TEST(clang_parser, builtin_headers) @@ -228,24 +228,24 @@ TEST(clang_parser, builtin_headers) StructMap structs; parse("#include \nstruct Foo { size_t x, y, z; }", structs); - ASSERT_EQ(structs.count("Foo"), 1); + ASSERT_EQ(structs.count("Foo"), 1U); EXPECT_EQ(structs["Foo"].size, 24); - ASSERT_EQ(structs["Foo"].fields.size(), 3); - ASSERT_EQ(structs["Foo"].fields.count("x"), 1); - ASSERT_EQ(structs["Foo"].fields.count("y"), 1); - ASSERT_EQ(structs["Foo"].fields.count("z"), 1); + ASSERT_EQ(structs["Foo"].fields.size(), 3U); + ASSERT_EQ(structs["Foo"].fields.count("x"), 1U); + ASSERT_EQ(structs["Foo"].fields.count("y"), 1U); + ASSERT_EQ(structs["Foo"].fields.count("z"), 1U); EXPECT_EQ(structs["Foo"].fields["x"].type.type, Type::integer); - EXPECT_EQ(structs["Foo"].fields["x"].type.size, 8); + EXPECT_EQ(structs["Foo"].fields["x"].type.size, 8U); EXPECT_EQ(structs["Foo"].fields["x"].offset, 0); EXPECT_EQ(structs["Foo"].fields["y"].type.type, Type::integer); - EXPECT_EQ(structs["Foo"].fields["y"].type.size, 8); + EXPECT_EQ(structs["Foo"].fields["y"].type.size, 8U); EXPECT_EQ(structs["Foo"].fields["y"].offset, 8); EXPECT_EQ(structs["Foo"].fields["z"].type.type, Type::integer); - EXPECT_EQ(structs["Foo"].fields["z"].type.size, 8); + EXPECT_EQ(structs["Foo"].fields["z"].type.size, 8U); EXPECT_EQ(structs["Foo"].fields["z"].offset, 16); } diff --git a/tests/codegen/general.cpp b/tests/codegen/general.cpp index 0711eb0c604..e7e74399e12 100644 --- a/tests/codegen/general.cpp +++ b/tests/codegen/general.cpp @@ -32,9 +32,9 @@ TEST(codegen, populate_sections) auto bpforc = codegen.compile(); // Check sections are populated - EXPECT_EQ(bpforc->sections_.size(), 2); - EXPECT_EQ(bpforc->sections_.count("s_kprobe:foo_1"), 1); - EXPECT_EQ(bpforc->sections_.count("s_kprobe:bar_1"), 1); + EXPECT_EQ(bpforc->sections_.size(), 2U); + EXPECT_EQ(bpforc->sections_.count("s_kprobe:foo_1"), 1U); + EXPECT_EQ(bpforc->sections_.count("s_kprobe:bar_1"), 1U); } TEST(codegen, printf_offsets) @@ -53,22 +53,22 @@ TEST(codegen, printf_offsets) ast::CodegenLLVM codegen(driver.root_, bpftrace); auto bpforc = codegen.compile(); - EXPECT_EQ(bpftrace.printf_args_.size(), 1); + EXPECT_EQ(bpftrace.printf_args_.size(), 1U); auto &fmt = std::get<0>(bpftrace.printf_args_[0]); auto &args = std::get<1>(bpftrace.printf_args_[0]); EXPECT_EQ(fmt, "%c %u\n"); - EXPECT_EQ(args.size(), 2); + EXPECT_EQ(args.size(), 2U); // NOTE (mmarchini) type.size is the original arg size, and it might be // different from the actual size we use to store in memory EXPECT_EQ(args[0].type.type, Type::integer); - EXPECT_EQ(args[0].type.size, 8); + EXPECT_EQ(args[0].type.size, 8U); EXPECT_EQ(args[0].offset, 8); EXPECT_EQ(args[1].type.type, Type::integer); - EXPECT_EQ(args[1].type.size, 8); + EXPECT_EQ(args[1].type.size, 8U); EXPECT_EQ(args[1].offset, 16); }