Mirrors/plcrashreporter
0
0
Fork 0
mirror of https://github.com/microsoft/plcrashreporter.git synced 2026-01-18 04:01:18 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #71 from microsoft/fix/cast-warnings

Browse Source 
Enable showing and fix existing warning
This commit is contained in:
Ivan Matkov
2020-04-30 19:02:16 +03:00
committed by GitHub
parent cf2ca3f230 5fd6afcbc1
commit 11f11ca052
28 changed files with 157 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
CrashReporter.xcodeproj/project.pbxproj
View File

@@ -442,9 +442,9 @@
C2B72B2624534EE700D03ABD /* protobuf-c.h in Headers */ = {isa = PBXBuildFile; fileRef = C2B72B2424534EE700D03ABD /* protobuf-c.h */; };
C2B72B2724534EE700D03ABD /* protobuf-c.h in Headers */ = {isa = PBXBuildFile; fileRef = C2B72B2424534EE700D03ABD /* protobuf-c.h */; };
C2B72B2824534EE700D03ABD /* protobuf-c.h in Headers */ = {isa = PBXBuildFile; fileRef = C2B72B2424534EE700D03ABD /* protobuf-c.h */; };
C2B72B2924534EE700D03ABD /* protobuf-c.c in Sources */ = {isa = PBXBuildFile; fileRef = C2B72B2524534EE700D03ABD /* protobuf-c.c */; };
C2B72B2A24534EE700D03ABD /* protobuf-c.c in Sources */ = {isa = PBXBuildFile; fileRef = C2B72B2524534EE700D03ABD /* protobuf-c.c */; };
C2B72B2B24534EE700D03ABD /* protobuf-c.c in Sources */ = {isa = PBXBuildFile; fileRef = C2B72B2524534EE700D03ABD /* protobuf-c.c */; };
C2B72B2924534EE700D03ABD /* protobuf-c.c in Sources */ = {isa = PBXBuildFile; fileRef = C2B72B2524534EE700D03ABD /* protobuf-c.c */; settings = {COMPILER_FLAGS = "-Wno-shorten-64-to-32"; }; };
C2B72B2A24534EE700D03ABD /* protobuf-c.c in Sources */ = {isa = PBXBuildFile; fileRef = C2B72B2524534EE700D03ABD /* protobuf-c.c */; settings = {COMPILER_FLAGS = "-Wno-shorten-64-to-32"; }; };
C2B72B2B24534EE700D03ABD /* protobuf-c.c in Sources */ = {isa = PBXBuildFile; fileRef = C2B72B2524534EE700D03ABD /* protobuf-c.c */; settings = {COMPILER_FLAGS = "-Wno-shorten-64-to-32"; }; };
C2BBCD9A2456E09000F9E820 /* PLCrashTestThread.m in Sources */ = {isa = PBXBuildFile; fileRef = C29AD6CD2456C94A00360AF7 /* PLCrashTestThread.m */; };
C2BBCD9B2456E0E700F9E820 /* PLCrashAsyncDwarfEncodingTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = C2BBCD7F2456E03D00F9E820 /* PLCrashAsyncDwarfEncodingTests.mm */; };
C2BBCD9C2456E0E700F9E820 /* PLCrashAsyncLinkedListTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = C2BBCD822456E03D00F9E820 /* PLCrashAsyncLinkedListTests.mm */; };
@@ -3632,6 +3632,7 @@
DYLIB_COMPATIBILITY_VERSION = 1;
DYLIB_CURRENT_VERSION = 1;
ENABLE_TESTABILITY = YES;
GCC_C_LANGUAGE_STANDARD = c99;
GCC_ENABLE_CPP_EXCEPTIONS = NO;
GCC_NO_COMMON_BLOCKS = YES;
GCC_OPTIMIZATION_LEVEL = 0;
@@ -3642,7 +3643,7 @@
PLCR_PRIVATE,
PLCF_DEBUG_BUILD,
);
GCC_WARN_64_TO_32_BIT_CONVERSION = NO;
GCC_TREAT_WARNINGS_AS_ERRORS = YES;
HEADER_SEARCH_PATHS = "\"$(SRCROOT)/Dependencies/protobuf-c\"";
IPHONEOS_DEPLOYMENT_TARGET = 8.0;
MACOSX_DEPLOYMENT_TARGET = 10.7;
@@ -3652,6 +3653,7 @@
PRODUCT_NAME = CrashReporter;
PROTOBUF_C_UNPACK_ERROR = PLCF_DEBUG;
TVOS_DEPLOYMENT_TARGET = 9.0;
WARNING_CFLAGS = "-Wall";
};
name = Debug;
};
@@ -3669,6 +3671,7 @@
DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
DYLIB_COMPATIBILITY_VERSION = 1;
DYLIB_CURRENT_VERSION = 1;
GCC_C_LANGUAGE_STANDARD = c99;
GCC_ENABLE_CPP_EXCEPTIONS = NO;
GCC_NO_COMMON_BLOCKS = YES;
GCC_PRECOMPILE_PREFIX_HEADER = YES;
@@ -3678,7 +3681,7 @@
PLCR_PRIVATE,
PLCF_RELEASE_BUILD,
);
GCC_WARN_64_TO_32_BIT_CONVERSION = NO;
GCC_TREAT_WARNINGS_AS_ERRORS = YES;
HEADER_SEARCH_PATHS = "\"$(SRCROOT)/Dependencies/protobuf-c\"";
IPHONEOS_DEPLOYMENT_TARGET = 8.0;
MACOSX_DEPLOYMENT_TARGET = 10.7;
@@ -3688,6 +3691,7 @@
PROTOBUF_C_UNPACK_ERROR = PLCF_DEBUG;
TVOS_DEPLOYMENT_TARGET = 9.0;
VALIDATE_PRODUCT = YES;
WARNING_CFLAGS = "-Wall";
};
name = Release;
};

16
Source/PLCrashAsyncCompactUnwindEncoding.c
View File

@@ -249,7 +249,7 @@ plcrash_error_t plcrash_async_cfe_reader_find_pc (plcrash_async_cfe_reader_t *re
return PLCRASH_EINVAL;
}
if (!plcrash_async_mobject_verify_local_pointer(reader->mobj, header, entries_offset, entries_count * sizeof(struct unwind_info_regular_second_level_entry))) {
if (!plcrash_async_mobject_verify_local_pointer(reader->mobj, (uintptr_t)header, entries_offset, entries_count * sizeof(struct unwind_info_regular_second_level_entry))) {
PLCF_DEBUG("CFE entries table lies outside the mapped CFE range");
return PLCRASH_EINVAL;
}
@@ -292,7 +292,7 @@ plcrash_error_t plcrash_async_cfe_reader_find_pc (plcrash_async_cfe_reader_t *re
return PLCRASH_EINVAL;
}
if (!plcrash_async_mobject_verify_local_pointer(reader->mobj, header, entries_offset, entries_count * sizeof(uint32_t))) {
if (!plcrash_async_mobject_verify_local_pointer(reader->mobj, (uintptr_t)header, entries_offset, entries_count * sizeof(uint32_t))) {
PLCF_DEBUG("CFE entries table lies outside the mapped CFE range");
return PLCRASH_EINVAL;
}
@@ -334,7 +334,7 @@ plcrash_error_t plcrash_async_cfe_reader_find_pc (plcrash_async_cfe_reader_t *re
return PLCRASH_EINVAL;
}
if (!plcrash_async_mobject_verify_local_pointer(reader->mobj, header, encodings_offset, encodings_count * sizeof(uint32_t))) {
if (!plcrash_async_mobject_verify_local_pointer(reader->mobj, (uintptr_t)header, encodings_offset, encodings_count * sizeof(uint32_t))) {
PLCF_DEBUG("CFE compressed encodings table lies outside the mapped CFE range");
return PLCRASH_EINVAL;
}
@@ -359,8 +359,11 @@ plcrash_error_t plcrash_async_cfe_reader_find_pc (plcrash_async_cfe_reader_t *re
}
// Unreachable
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
__builtin_trap();
return PLCRASH_ENOTFOUND;
#pragma clang diagnostic pop
}
/**
@@ -769,9 +772,11 @@ plcrash_error_t plcrash_async_cfe_entry_init (plcrash_async_cfe_entry_t *entry,
}
// Unreachable
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
__builtin_trap();
return PLCRASH_EINTERNAL;
#pragma clang diagnostic pop
} else if (cpu_type == CPU_TYPE_X86_64) {
uint32_t mode = encoding & UNWIND_X86_64_MODE_MASK;
switch (mode) {
@@ -865,8 +870,11 @@ plcrash_error_t plcrash_async_cfe_entry_init (plcrash_async_cfe_entry_t *entry,
}
// Unreachable
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
__builtin_trap();
return PLCRASH_EINTERNAL;
#pragma clang diagnostic pop
} else if (cpu_type == CPU_TYPE_ARM64) {
uint32_t mode = encoding & UNWIND_ARM64_MODE_MASK;
switch (mode) {

4
Source/PLCrashAsyncDwarfCFAState.cpp
View File

@@ -191,7 +191,7 @@ bool dwarf_cfa_state<machine_ptr, machine_ptr_s>::get_register_rule (dwarf_cfa_s
}
/* Existing entry found, we can re-use it directly */
*value = entry->value;
*value = (machine_ptr)entry->value;
*rule = (plcrash_dwarf_cfa_reg_rule_t) entry->rule;
return true;
}
@@ -336,7 +336,7 @@ bool dwarf_cfa_state_iterator<machine_ptr, machine_ptr_s>::next (dwarf_cfa_state
typename dwarf_cfa_state<machine_ptr, machine_ptr_s>::dwarf_cfa_reg_entry_t *entry = &_stack->_entries[_cur_entry_idx];
*regnum = entry->regnum;
*value = entry->value;
*value = (machine_ptr)entry->value;
*rule = (plcrash_dwarf_cfa_reg_rule_t) entry->rule;
return true;
}

22
Source/PLCrashAsyncDwarfCFAStateEvaluation.cpp
View File

@@ -227,11 +227,11 @@ plcrash_error_t dwarf_cfa_state<machine_ptr, machine_ptr_s>::eval_program (plcra
break;
case DW_CFA_def_cfa:
set_cfa_register(dw_expr_read_uleb128_regnum(), dw_expr_read_uleb128());
set_cfa_register(dw_expr_read_uleb128_regnum(), (machine_ptr)dw_expr_read_uleb128());
break;
case DW_CFA_def_cfa_sf:
set_cfa_register_signed(dw_expr_read_uleb128_regnum(), dw_expr_read_sleb128() * cie_info->data_alignment_factor);
set_cfa_register_signed(dw_expr_read_uleb128_regnum(), (machine_ptr_s)(dw_expr_read_sleb128() * cie_info->data_alignment_factor));
break;
case DW_CFA_def_cfa_register: {
@@ -260,7 +260,7 @@ plcrash_error_t dwarf_cfa_state<machine_ptr, machine_ptr_s>::eval_program (plcra
case DWARF_CFA_STATE_CFA_TYPE_REGISTER:
case DWARF_CFA_STATE_CFA_TYPE_REGISTER_SIGNED:
/* Our new offset is unsigned, so all register rules are converted to unsigned here */
set_cfa_register(rule.register_number(), dw_expr_read_uleb128());
set_cfa_register(rule.register_number(), (machine_ptr)dw_expr_read_uleb128());
break;
case DWARF_CFA_STATE_CFA_TYPE_EXPRESSION:
@@ -278,7 +278,7 @@ plcrash_error_t dwarf_cfa_state<machine_ptr, machine_ptr_s>::eval_program (plcra
case DWARF_CFA_STATE_CFA_TYPE_REGISTER:
case DWARF_CFA_STATE_CFA_TYPE_REGISTER_SIGNED:
/* Our new offset is signed, so all register rules are converted to signed here */
set_cfa_register_signed(rule.register_number(), dw_expr_read_sleb128() * cie_info->data_alignment_factor);
set_cfa_register_signed(rule.register_number(), (machine_ptr_s)(dw_expr_read_sleb128() * cie_info->data_alignment_factor));
break;
case DWARF_CFA_STATE_CFA_TYPE_EXPRESSION:
@@ -340,27 +340,27 @@ plcrash_error_t dwarf_cfa_state<machine_ptr, machine_ptr_s>::eval_program (plcra
break;
case DW_CFA_offset:
dw_expr_set_register(const_operand, PLCRASH_DWARF_CFA_REG_RULE_OFFSET, dw_expr_read_uleb128() * cie_info->data_alignment_factor);
dw_expr_set_register(const_operand, PLCRASH_DWARF_CFA_REG_RULE_OFFSET, (machine_ptr)(dw_expr_read_uleb128() * cie_info->data_alignment_factor));
break;
case DW_CFA_offset_extended:
dw_expr_set_register(dw_expr_read_uleb128_regnum(), PLCRASH_DWARF_CFA_REG_RULE_OFFSET, dw_expr_read_uleb128() * cie_info->data_alignment_factor);
dw_expr_set_register(dw_expr_read_uleb128_regnum(), PLCRASH_DWARF_CFA_REG_RULE_OFFSET, (machine_ptr)(dw_expr_read_uleb128() * cie_info->data_alignment_factor));
break;
case DW_CFA_offset_extended_sf:
dw_expr_set_register(dw_expr_read_uleb128_regnum(), PLCRASH_DWARF_CFA_REG_RULE_OFFSET, dw_expr_read_sleb128() * cie_info->data_alignment_factor);
dw_expr_set_register(dw_expr_read_uleb128_regnum(), PLCRASH_DWARF_CFA_REG_RULE_OFFSET, (machine_ptr)(dw_expr_read_sleb128() * cie_info->data_alignment_factor));
break;
case DW_CFA_val_offset:
dw_expr_set_register(dw_expr_read_uleb128_regnum(), PLCRASH_DWARF_CFA_REG_RULE_VAL_OFFSET, dw_expr_read_uleb128() * cie_info->data_alignment_factor);
dw_expr_set_register(dw_expr_read_uleb128_regnum(), PLCRASH_DWARF_CFA_REG_RULE_VAL_OFFSET, (machine_ptr)(dw_expr_read_uleb128() * cie_info->data_alignment_factor));
break;
case DW_CFA_val_offset_sf:
dw_expr_set_register(dw_expr_read_uleb128_regnum(), PLCRASH_DWARF_CFA_REG_RULE_VAL_OFFSET, dw_expr_read_sleb128() * cie_info->data_alignment_factor);
dw_expr_set_register(dw_expr_read_uleb128_regnum(), PLCRASH_DWARF_CFA_REG_RULE_VAL_OFFSET, (machine_ptr)(dw_expr_read_sleb128() * cie_info->data_alignment_factor));
break;
case DW_CFA_register:
dw_expr_set_register(dw_expr_read_uleb128_regnum(), PLCRASH_DWARF_CFA_REG_RULE_REGISTER, dw_expr_read_uleb128());
dw_expr_set_register(dw_expr_read_uleb128_regnum(), PLCRASH_DWARF_CFA_REG_RULE_REGISTER, (machine_ptr)dw_expr_read_uleb128());
break;
case DW_CFA_expression:
@@ -511,7 +511,7 @@ plcrash_error_t dwarf_cfa_state<machine_ptr, machine_ptr_s>::apply_state (task_t
}
/* Fetch the current value, apply the offset, and save as the new thread's CFA. */
cfa_val = plcrash_async_thread_state_get_reg(thread_state, regnum);
cfa_val = (machine_ptr) plcrash_async_thread_state_get_reg(thread_state, regnum);
if (cfa_rule.type() == DWARF_CFA_STATE_CFA_TYPE_REGISTER)
cfa_val += cfa_rule.register_offset();
else

4
Source/PLCrashAsyncDwarfExpression.cpp
View File

@@ -153,7 +153,7 @@ plcrash_error_t plcrash_async_dwarf_expression_eval (plcrash_async_mobject_t *mo
})
/* A push macro that handles reporting of stack overflow errors */
#define dw_expr_push(v) if (!stack.push(v)) { \
#define dw_expr_push(v) if (!stack.push((machine_ptr_s)v)) { \
PLCF_DEBUG("Hit stack limit; cannot push further values"); \
return PLCRASH_EINTERNAL; \
}
@@ -394,7 +394,7 @@ plcrash_error_t plcrash_async_dwarf_expression_eval (plcrash_async_mobject_t *mo
PLCF_DEBUG("DW_OP_deref_size referenced an invalid target address 0x%" PRIx64, (uint64_t) addr); \
return err; \
} \
value = r; \
value = (machine_ptr)r; \
break; \
}
machine_ptr value = 0;

12
Source/PLCrashAsyncDwarfPrimitives.cpp
View File

@@ -145,7 +145,7 @@ template <typename machine_ptr> plcrash_error_t gnu_ehptr_reader<machine_ptr>::r
* be used for the DW_EH_PE_pcrel base address; reviewing the available implementations demonstrates that
* the current read buffer position should be used.
*/
base = location + offset;
base = (machine_ptr)(location + offset);
break;
case DW_EH_PE_absptr:
@@ -187,7 +187,7 @@ template <typename machine_ptr> plcrash_error_t gnu_ehptr_reader<machine_ptr>::r
/* Compute the offset+alignment relative to the section base */
PLCF_ASSERT(location >= _frame_section_base);
machine_ptr locationOffset = location - _frame_section_base;
machine_ptr locationOffset = (machine_ptr)location - _frame_section_base;
/* Apply to the VM load address for the section. */
machine_ptr vm_addr = _frame_section_vm_addr + locationOffset;
@@ -238,7 +238,7 @@ template <typename machine_ptr> plcrash_error_t gnu_ehptr_reader<machine_ptr>::r
return err;
}
*result = ulebv + base;
*result = (machine_ptr)(ulebv + base);
*size += uleb_size;
break;
}
@@ -274,7 +274,7 @@ template <typename machine_ptr> plcrash_error_t gnu_ehptr_reader<machine_ptr>::r
return err;
}
*result = udata8 + base;
*result = (machine_ptr)(udata8 + base);
*size += 8;
break;
}
@@ -288,7 +288,7 @@ template <typename machine_ptr> plcrash_error_t gnu_ehptr_reader<machine_ptr>::r
return err;
}
*result = slebv + base;
*result = (machine_ptr)(slebv + base);
*size += sleb_size;
break;
}
@@ -325,7 +325,7 @@ template <typename machine_ptr> plcrash_error_t gnu_ehptr_reader<machine_ptr>::r
return err;
}
*result = sdata8 + base;
*result = (machine_ptr)(sdata8 + base);
*size += 8;
break;
}

4
Source/PLCrashAsyncDwarfPrimitives.hpp
View File

@@ -393,7 +393,7 @@ plcrash_error_t plcrash_async_dwarf_read_uintmax64 (plcrash_async_mobject_t *mob
break;
case 8:
*dest = byteorder->swap64(data->u64);
*dest = (T)byteorder->swap64(data->u64);
break;
default:
@@ -457,7 +457,7 @@ plcrash_error_t plcrash_async_dwarf_read_task_uintmax64 (task_t task,
case 8:
if ((err = plcrash_async_task_read_uint64(task, byteorder, base_addr, offset, &data.u64)) != PLCRASH_ESUCCESS)
return err;
*dest = data.u64;
*dest = (T)data.u64;
break;
default:

12
Source/PLCrashAsyncMachExceptionInfo.c
View File

@@ -75,22 +75,22 @@ bool plcrash_async_mach_exception_get_siginfo (exception_type_t exception_type,
siginfo->si_signo = SIGBUS;
}
siginfo->si_addr = subcode;
siginfo->si_addr = (void *)subcode;
break;
case EXC_BAD_INSTRUCTION:
siginfo->si_signo = SIGILL;
siginfo->si_addr = subcode;
siginfo->si_addr = (void *)subcode;
break;
case EXC_ARITHMETIC:
siginfo->si_signo = SIGFPE;
siginfo->si_addr = subcode;
siginfo->si_addr = (void *)subcode;
break;
case EXC_EMULATION:
siginfo->si_signo = SIGEMT;
siginfo->si_addr = subcode;
siginfo->si_addr = (void *)subcode;
break;
case EXC_SOFTWARE:
@@ -116,12 +116,12 @@ bool plcrash_async_mach_exception_get_siginfo (exception_type_t exception_type,
break;
}
siginfo->si_addr = subcode;
siginfo->si_addr = (void *)subcode;
break;
case EXC_BREAKPOINT:
siginfo->si_signo = SIGTRAP;
siginfo->si_addr = subcode;
siginfo->si_addr = (void *)subcode;
break;
default:

4
Source/PLCrashAsyncObjCSection.mm
View File

@@ -966,7 +966,7 @@ static plcrash_error_t pl_async_objc_parse_from_data_section (plcrash_async_mach
/* Figure out how many classes are in the class list based on its length and
* the size of a pointer in the image. */
unsigned classCount = objcContext->classMobj.length / sizeof(machine_ptr_t);
pl_vm_size_t classCount = objcContext->classMobj.length / sizeof(machine_ptr_t);
/* Iterate over all classes. */
for(unsigned i = 0; i < classCount; i++) {
@@ -1016,7 +1016,7 @@ static plcrash_error_t pl_async_objc_parse_from_data_section (plcrash_async_mach
}
/* Figure out how many categories are in the category list based on its length and the size of a pointer in the image. */
unsigned catCount = objcContext->catMobj.length / sizeof(*catPtrs);
pl_vm_size_t catCount = objcContext->catMobj.length / sizeof(*catPtrs);
/* Iterate over all classes. */
for(unsigned i = 0; i < catCount; i++) {

40
Source/PLCrashAsyncThread_arm.c
View File

@@ -315,23 +315,23 @@ plcrash_greg_t plcrash_async_thread_state_get_reg (const plcrash_async_thread_st
static inline void plcrash_async_thread_state_set_reg_32 (plcrash_async_thread_state_t *ts, plcrash_regnum_t regnum, plcrash_greg_t reg) {
switch (regnum) {
case PLCRASH_ARM_R0: THREAD_STATE_SET(r[0], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R1: THREAD_STATE_SET(r[1], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R2: THREAD_STATE_SET(r[2], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R3: THREAD_STATE_SET(r[3], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R4: THREAD_STATE_SET(r[4], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R5: THREAD_STATE_SET(r[5], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R6: THREAD_STATE_SET(r[6], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R7: THREAD_STATE_SET(r[7], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R8: THREAD_STATE_SET(r[8], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R9: THREAD_STATE_SET(r[9], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R10: THREAD_STATE_SET(r[10], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R11: THREAD_STATE_SET(r[11], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R12: THREAD_STATE_SET(r[12], thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_SP: THREAD_STATE_SET(sp, thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_LR: THREAD_STATE_SET(lr, thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_PC: THREAD_STATE_SET(pc, thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_CPSR: THREAD_STATE_SET(cpsr, thread.ts_32, ts, regnum, reg); break;
case PLCRASH_ARM_R0: THREAD_STATE_SET(r[0], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R1: THREAD_STATE_SET(r[1], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R2: THREAD_STATE_SET(r[2], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R3: THREAD_STATE_SET(r[3], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R4: THREAD_STATE_SET(r[4], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R5: THREAD_STATE_SET(r[5], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R6: THREAD_STATE_SET(r[6], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R7: THREAD_STATE_SET(r[7], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R8: THREAD_STATE_SET(r[8], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R9: THREAD_STATE_SET(r[9], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R10: THREAD_STATE_SET(r[10], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R11: THREAD_STATE_SET(r[11], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_R12: THREAD_STATE_SET(r[12], thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_SP: THREAD_STATE_SET(sp, thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_LR: THREAD_STATE_SET(lr, thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_PC: THREAD_STATE_SET(pc, thread.ts_32, ts, regnum, (uint32_t)reg); break;
case PLCRASH_ARM_CPSR: THREAD_STATE_SET(cpsr, thread.ts_32, ts, regnum, (uint32_t)reg); break;
default: __builtin_trap(); // Unsupported register
}
}
@@ -371,7 +371,7 @@ static inline void plcrash_async_thread_state_set_reg_64 (plcrash_async_thread_s
case PLCRASH_ARM64_SP: THREAD_STATE_SET_PTR(sp, thread.ts_64, ts, regnum, reg); break;
case PLCRASH_ARM64_LR: THREAD_STATE_SET_FPTR(lr, thread.ts_64, ts, regnum, reg); break;
case PLCRASH_ARM64_PC: THREAD_STATE_SET_FPTR(pc, thread.ts_64, ts, regnum, reg); break;
case PLCRASH_ARM64_CPSR: THREAD_STATE_SET(cpsr, thread.ts_64, ts, regnum, reg); break;
case PLCRASH_ARM64_CPSR: THREAD_STATE_SET(cpsr, thread.ts_64, ts, regnum, (uint32_t)reg); break;
default: __builtin_trap();
}
}
@@ -489,7 +489,7 @@ void plcrash_async_thread_state_clear_volatile_regs (plcrash_async_thread_state_
size_t reg_count = plcrash_async_thread_state_get_reg_count(thread_state);
for (size_t reg = 0; reg < reg_count; reg++) {
/* Skip unset registers */
if (!plcrash_async_thread_state_has_reg(thread_state, reg))
if (!plcrash_async_thread_state_has_reg(thread_state, (uint32_t)reg))
continue;
/* Check for the register in the preservation table */
@@ -503,7 +503,7 @@ void plcrash_async_thread_state_clear_volatile_regs (plcrash_async_thread_state_
/* If not preserved, clear */
if (!preserved)
plcrash_async_thread_state_clear_reg(thread_state, reg);
plcrash_async_thread_state_clear_reg(thread_state, (uint32_t)reg);
}
}

34
Source/PLCrashAsyncThread_x86.c
View File

@@ -202,8 +202,8 @@ void plcrash_async_thread_state_clear_volatile_regs (plcrash_async_thread_state_
table_count = sizeof(x86_64_nonvolatile_registers) / sizeof(x86_64_nonvolatile_registers[0]);
}
size_t reg_count = plcrash_async_thread_state_get_reg_count(thread_state);
for (size_t reg = 0; reg < reg_count; reg++) {
plcrash_regnum_t reg_count = (plcrash_regnum_t) plcrash_async_thread_state_get_reg_count(thread_state);
for (plcrash_regnum_t reg = 0; reg < reg_count; reg++) {
/* Skip unset registers */
if (!plcrash_async_thread_state_has_reg(thread_state, reg))
continue;
@@ -427,52 +427,52 @@ static void plcrash_async_thread_state_set_reg_32 (plcrash_async_thread_state_t
/* All word-sized registers */
switch (regnum) {
case PLCRASH_X86_EAX:
SETGEN(eax, thread.uts.ts32, ts, regnum, reg);
SETGEN(eax, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_EDX:
SETGEN(edx, thread.uts.ts32, ts, regnum, reg);
SETGEN(edx, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_ECX:
SETGEN(ecx, thread.uts.ts32, ts, regnum, reg);
SETGEN(ecx, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_EBX:
SETGEN(ebx, thread.uts.ts32, ts, regnum, reg);
SETGEN(ebx, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_EBP:
SETGEN(ebp, thread.uts.ts32, ts, regnum, reg);
SETGEN(ebp, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_ESI:
SETGEN(esi, thread.uts.ts32, ts, regnum, reg);
SETGEN(esi, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_EDI:
SETGEN(edi, thread.uts.ts32, ts, regnum, reg);
SETGEN(edi, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_ESP:
SETGEN(esp, thread.uts.ts32, ts, regnum, reg);
SETGEN(esp, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_EIP:
SETGEN(eip, thread.uts.ts32, ts, regnum, reg);
SETGEN(eip, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_EFLAGS:
SETGEN(eflags, thread.uts.ts32, ts, regnum, reg);
SETGEN(eflags, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_TRAPNO:
SETGEN(trapno, exception.ues.es32, ts, regnum, reg);
case PLCRASH_X86_CS:
SETGEN(cs, thread.uts.ts32, ts, regnum, reg);
SETGEN(cs, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_DS:
SETGEN(ds, thread.uts.ts32, ts, regnum, reg);
SETGEN(ds, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_ES:
SETGEN(es, thread.uts.ts32, ts, regnum, reg);
SETGEN(es, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_FS:
SETGEN(fs, thread.uts.ts32, ts, regnum, reg);
SETGEN(fs, thread.uts.ts32, ts, regnum, (uint32_t)reg);
case PLCRASH_X86_GS:
SETGEN(gs, thread.uts.ts32, ts, regnum, reg);
SETGEN(gs, thread.uts.ts32, ts, regnum, (uint32_t)reg);
default:
// Unsupported register

6
Source/PLCrashFrameDWARFUnwind.cpp
View File

@@ -160,7 +160,7 @@ static plframe_error_t plframe_cursor_read_dwarf_unwind_int (task_t task,
PLCF_ASSERT(fde_info.pc_start < std::numeric_limits<machine_ptr>::max());
/* Initial instructions */
err = cfa_state.eval_program(dwarf_section, pc, fde_info.pc_start, &cie_info, &ptr_state, image->byteorder, plcrash_async_mobject_base_address(dwarf_section), cie_info.initial_instructions_offset, cie_info.initial_instructions_length);
err = cfa_state.eval_program(dwarf_section, pc, (uint32_t)fde_info.pc_start, &cie_info, &ptr_state, image->byteorder, plcrash_async_mobject_base_address(dwarf_section), cie_info.initial_instructions_offset, cie_info.initial_instructions_length);
if (err != PLCRASH_ESUCCESS) {
PLCF_DEBUG("Failed to evaluate CFA at offset of 0x%" PRIx64 ": %d", (uint64_t) fde_info.instructions_offset, err);
result = PLFRAME_ENOTSUP;
@@ -168,7 +168,7 @@ static plframe_error_t plframe_cursor_read_dwarf_unwind_int (task_t task,
}
/* FDE instructions */
err = cfa_state.eval_program(dwarf_section, pc, fde_info.pc_start, &cie_info, &ptr_state, image->byteorder, plcrash_async_mobject_base_address(dwarf_section), fde_info.instructions_offset, fde_info.instructions_length);
err = cfa_state.eval_program(dwarf_section, pc, (uint32_t)fde_info.pc_start, &cie_info, &ptr_state, image->byteorder, plcrash_async_mobject_base_address(dwarf_section), fde_info.instructions_offset, fde_info.instructions_length);
if (err != PLCRASH_ESUCCESS) {
PLCF_DEBUG("Failed to evaluate CFA at offset of 0x%" PRIx64 ": %d", (uint64_t) fde_info.instructions_offset, err);
result = PLFRAME_ENOTSUP;
@@ -249,7 +249,7 @@ plframe_error_t plframe_cursor_read_dwarf_unwind (task_t task,
/* Could only happen due to programmer error; eg, an image that doesn't actually match our thread state */
PLCF_ASSERT(pc <= UINT32_MAX);
ferr = plframe_cursor_read_dwarf_unwind_int<uint32_t, int32_t>(task, pc, &image->macho_image, current_frame, previous_frame, next_frame);
ferr = plframe_cursor_read_dwarf_unwind_int<uint32_t, int32_t>(task, (uint32_t)pc, &image->macho_image, current_frame, previous_frame, next_frame);
}
plcrash_async_image_list_set_reading(image_list, false);

2
Source/PLCrashFrameWalker.c
View File

@@ -120,7 +120,7 @@ plframe_error_t plframe_cursor_thread_init (plframe_cursor_t *cursor, task_t tas
/* Standard initialization */
plframe_cursor_internal_init(cursor, task, image_list);
return plcrash_async_thread_state_mach_thread_init(&cursor->frame.thread_state, thread);
return (plframe_error_t)plcrash_async_thread_state_mach_thread_init(&cursor->frame.thread_state, thread);
}
/**

34
Source/PLCrashLogWriter.m
View File

@@ -634,7 +634,7 @@ static size_t plcrash_writer_write_machine_info (plcrash_async_file_t *file, plc
uint32_t size;
/* Determine size */
size = plcrash_writer_write_processor_info(NULL, writer->machine_info.cpu_type, writer->machine_info.cpu_subtype);
size = (uint32_t) plcrash_writer_write_processor_info(NULL, writer->machine_info.cpu_type, writer->machine_info.cpu_subtype);
/* Write message */
rv += plcrash_writer_pack(file, PLCRASH_PROTO_MACHINE_INFO_PROCESSOR_ID, PLPROTOBUF_C_TYPE_MESSAGE, &size);
@@ -774,7 +774,7 @@ static size_t plcrash_writer_write_thread_register (plcrash_async_file_t *file,
*/
static size_t plcrash_writer_write_thread_registers (plcrash_async_file_t *file, task_t task, plframe_cursor_t *cursor) {
plframe_error_t frame_err;
uint32_t regCount = plframe_cursor_get_regcount(cursor);
uint32_t regCount = (uint32_t) plframe_cursor_get_regcount(cursor);
size_t rv = 0;
/* Write out register messages */
@@ -794,7 +794,7 @@ static size_t plcrash_writer_write_thread_registers (plcrash_async_file_t *file,
regname = plframe_cursor_get_regname(cursor, i);
/* Get the register message size */
msgsize = plcrash_writer_write_thread_register(NULL, regname, regVal);
msgsize = (uint32_t) plcrash_writer_write_thread_register(NULL, regname, regVal);
/* Write the header and message */
rv += plcrash_writer_pack(file, PLCRASH_PROTO_THREAD_REGISTERS_ID, PLPROTOBUF_C_TYPE_MESSAGE, &msgsize);
@@ -845,7 +845,7 @@ struct pl_symbol_cb_ctx {
*/
static void plcrash_writer_write_thread_frame_symbol_cb (pl_vm_address_t address, const char *name, void *ctx) {
struct pl_symbol_cb_ctx *cb_ctx = ctx;
cb_ctx->msgsize = plcrash_writer_write_symbol(cb_ctx->file, name, address);
cb_ctx->msgsize = (uint32_t) plcrash_writer_write_symbol(cb_ctx->file, name, address);
}
/**
@@ -976,7 +976,7 @@ static size_t plcrash_writer_write_thread (plcrash_async_file_t *file,
}
/* Determine the size */
frame_size = plcrash_writer_write_thread_frame(NULL, writer, pc, image_list, findContext);
frame_size = (uint32_t) plcrash_writer_write_thread_frame(NULL, writer, pc, image_list, findContext);
rv += plcrash_writer_pack(file, PLCRASH_PROTO_THREAD_FRAMES_ID, PLPROTOBUF_C_TYPE_MESSAGE, &frame_size);
rv += plcrash_writer_write_thread_frame(file, writer, pc, image_list, findContext);
@@ -1042,7 +1042,7 @@ static size_t plcrash_writer_write_binary_image (plcrash_async_file_t *file, plc
}
/* Get the processor message size */
uint32_t msgsize = plcrash_writer_write_processor_info(NULL, cpu_type, cpu_subtype);
uint32_t msgsize = (uint32_t) plcrash_writer_write_processor_info(NULL, cpu_type, cpu_subtype);
/* Write the header and message */
rv += plcrash_writer_pack(file, PLCRASH_PROTO_BINARY_IMAGE_CODE_TYPE_ID, PLPROTOBUF_C_TYPE_MESSAGE, &msgsize);
@@ -1074,7 +1074,7 @@ static size_t plcrash_writer_write_exception (plcrash_async_file_t *file, plcras
uint64_t pc = (uint64_t)(uintptr_t) writer->uncaught_exception.callstack[i];
/* Determine the size */
uint32_t frame_size = plcrash_writer_write_thread_frame(NULL, writer, pc, image_list, findContext);
uint32_t frame_size = (uint32_t) plcrash_writer_write_thread_frame(NULL, writer, pc, image_list, findContext);
rv += plcrash_writer_pack(file, PLCRASH_PROTO_EXCEPTION_FRAMES_ID, PLPROTOBUF_C_TYPE_MESSAGE, &frame_size);
rv += plcrash_writer_write_thread_frame(file, writer, pc, image_list, findContext);
@@ -1154,7 +1154,7 @@ static size_t plcrash_writer_write_signal (plcrash_async_file_t *file, plcrash_l
uint32_t size;
/* Determine size */
size = plcrash_writer_write_mach_signal(NULL, siginfo->mach_info);
size = (uint32_t) plcrash_writer_write_mach_signal(NULL, siginfo->mach_info);
/* Write message */
rv += plcrash_writer_pack(file, PLCRASH_PROTO_SIGNAL_MACH_EXCEPTION_ID, PLPROTOBUF_C_TYPE_MESSAGE, &size);
@@ -1250,7 +1250,7 @@ plcrash_error_t plcrash_log_writer_write (plcrash_log_writer_t *writer,
uint32_t size;
/* Determine size */
size = plcrash_writer_write_report_info(NULL, writer);
size = (uint32_t) plcrash_writer_write_report_info(NULL, writer);
/* Write message */
plcrash_writer_pack(file, PLCRASH_PROTO_REPORT_INFO_ID, PLPROTOBUF_C_TYPE_MESSAGE, &size);
@@ -1269,7 +1269,7 @@ plcrash_error_t plcrash_log_writer_write (plcrash_log_writer_t *writer,
}
/* Determine size */
size = plcrash_writer_write_system_info(NULL, writer, timestamp);
size = (uint32_t) plcrash_writer_write_system_info(NULL, writer, timestamp);
/* Write message */
plcrash_writer_pack(file, PLCRASH_PROTO_SYSTEM_INFO_ID, PLPROTOBUF_C_TYPE_MESSAGE, &size);
@@ -1281,7 +1281,7 @@ plcrash_error_t plcrash_log_writer_write (plcrash_log_writer_t *writer,
uint32_t size;
/* Determine size */
size = plcrash_writer_write_machine_info(NULL, writer);
size = (uint32_t) plcrash_writer_write_machine_info(NULL, writer);
/* Write message */
plcrash_writer_pack(file, PLCRASH_PROTO_MACHINE_INFO_ID, PLPROTOBUF_C_TYPE_MESSAGE, &size);
@@ -1293,7 +1293,7 @@ plcrash_error_t plcrash_log_writer_write (plcrash_log_writer_t *writer,
uint32_t size;
/* Determine size */
size = plcrash_writer_write_app_info(NULL, writer->application_info.app_identifier, writer->application_info.app_version, writer->application_info.app_marketing_version);
size = (uint32_t) plcrash_writer_write_app_info(NULL, writer->application_info.app_identifier, writer->application_info.app_version, writer->application_info.app_marketing_version);
/* Write message */
plcrash_writer_pack(file, PLCRASH_PROTO_APP_INFO_ID, PLPROTOBUF_C_TYPE_MESSAGE, &size);
@@ -1305,7 +1305,7 @@ plcrash_error_t plcrash_log_writer_write (plcrash_log_writer_t *writer,
uint32_t size;
/* Determine size */
size = plcrash_writer_write_process_info(NULL, writer->process_info.process_name, writer->process_info.process_id,
size = (uint32_t) plcrash_writer_write_process_info(NULL, writer->process_info.process_name, writer->process_info.process_id,
writer->process_info.process_path, writer->process_info.parent_process_name,
writer->process_info.parent_process_id, writer->process_info.native,
writer->process_info.start_time);
@@ -1341,7 +1341,7 @@ plcrash_error_t plcrash_log_writer_write (plcrash_log_writer_t *writer,
}
/* Determine the size */
size = plcrash_writer_write_thread(NULL, writer, mach_task_self(), thread, thread_number, thr_ctx, image_list, &findContext, crashed);
size = (uint32_t) plcrash_writer_write_thread(NULL, writer, mach_task_self(), thread, thread_number, thr_ctx, image_list, &findContext, crashed);
/* Write message */
plcrash_writer_pack(file, PLCRASH_PROTO_THREADS_ID, PLPROTOBUF_C_TYPE_MESSAGE, &size);
@@ -1358,7 +1358,7 @@ plcrash_error_t plcrash_log_writer_write (plcrash_log_writer_t *writer,
uint32_t size;
/* Calculate the message size */
size = plcrash_writer_write_binary_image(NULL, &image->macho_image);
size = (uint32_t) plcrash_writer_write_binary_image(NULL, &image->macho_image);
plcrash_writer_pack(file, PLCRASH_PROTO_BINARY_IMAGES_ID, PLPROTOBUF_C_TYPE_MESSAGE, &size);
plcrash_writer_write_binary_image(file, &image->macho_image);
}
@@ -1370,7 +1370,7 @@ plcrash_error_t plcrash_log_writer_write (plcrash_log_writer_t *writer,
uint32_t size;
/* Calculate the message size */
size = plcrash_writer_write_exception(NULL, writer, image_list, &findContext);
size = (uint32_t) plcrash_writer_write_exception(NULL, writer, image_list, &findContext);
plcrash_writer_pack(file, PLCRASH_PROTO_EXCEPTION_ID, PLPROTOBUF_C_TYPE_MESSAGE, &size);
plcrash_writer_write_exception(file, writer, image_list, &findContext);
}
@@ -1380,7 +1380,7 @@ plcrash_error_t plcrash_log_writer_write (plcrash_log_writer_t *writer,
uint32_t size;
/* Calculate the message size */
size = plcrash_writer_write_signal(NULL, siginfo);
size = (uint32_t) plcrash_writer_write_signal(NULL, siginfo);
plcrash_writer_pack(file, PLCRASH_PROTO_SIGNAL_ID, PLPROTOBUF_C_TYPE_MESSAGE, &size);
plcrash_writer_write_signal(file, siginfo);
}

8
Source/PLCrashLogWriterEncoding.c
View File

@@ -109,10 +109,10 @@ static size_t
uint64_pack (uint64_t value, uint8_t *out)
{
uint32_t hi = value>>32;
uint32_t lo = value;
uint32_t lo = (uint32_t) value;
unsigned rv;
if (hi == 0)
return uint32_pack ((uint32_t)lo, out);
return uint32_pack (lo, out);
out[0] = (lo) | 0x80;
out[1] = (lo>>7) | 0x80;
out[2] = (lo>>14) | 0x80;
@@ -242,7 +242,7 @@ size_t plcrash_writer_pack (plcrash_async_file_t *file, uint32_t field_id, PLPro
case PLPROTOBUF_C_TYPE_STRING:
{
size_t sublen = strlen (value);
uint32_t sublen = (uint32_t) strlen (value);
scratch[0] |= PLPROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
rv += uint32_pack (sublen, scratch + rv);
if (file != NULL) {
@@ -256,7 +256,7 @@ size_t plcrash_writer_pack (plcrash_async_file_t *file, uint32_t field_id, PLPro
case PLPROTOBUF_C_TYPE_BYTES:
{
const PLProtobufCBinaryData * bd = ((const PLProtobufCBinaryData*) value);
size_t sublen = bd->len;
uint32_t sublen = (uint32_t) bd->len;
scratch[0] |= PLPROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
rv += uint32_pack (sublen, scratch + rv);
if (file != NULL) {

4
Source/PLCrashMachExceptionServer.m
View File

@@ -564,7 +564,7 @@ kern_return_t PLCrashMachExceptionForward (task_t task,
/* We prefer 64-bit codes; if the user requests 32-bit codes, we need to map them */
exception_data_type_t code32[code_count];
for (mach_msg_type_number_t i = 0; i < code_count; i++) {
code32[i] = (uint64_t) code[i];
code32[i] = (exception_data_type_t)code[i];
}
/* Strip the MACH_EXCEPTION_CODES modifier from the behavior flags */
@@ -660,7 +660,7 @@ static void *exception_server_thread (void *arg) {
while (true) {
/* Initialize our request message */
request->Head.msgh_local_port = exc_context->port_set;
request->Head.msgh_size = request_size;
request->Head.msgh_size = (mach_msg_size_t)request_size;
mr = mach_msg(&request->Head,
MACH_RCV_MSG | MACH_RCV_LARGE,
0,

4
Tests/Libunwind Regression Tests/unwind_test_harness.c
View File

@@ -250,7 +250,7 @@ static plcrash_error_t unwind_current_state (plcrash_async_thread_state_t *state
/* Initialize the image list */
plcrash_nasync_image_list_init(&image_list, mach_task_self());
for (uint32_t i = 0; i < _dyld_image_count(); i++)
plcrash_nasync_image_list_append(&image_list, _dyld_get_image_header(i), _dyld_get_image_name(i));
plcrash_nasync_image_list_append(&image_list, (pl_vm_address_t) _dyld_get_image_header(i), _dyld_get_image_name(i));
/* Initialie our cursor */
plframe_cursor_init(&cursor, mach_task_self(), state, &image_list);
@@ -274,7 +274,7 @@ static plcrash_error_t unwind_current_state (plcrash_async_thread_state_t *state
if (err != PLFRAME_ESUCCESS) {
PLCF_DEBUG("Step within test function failed: %d (%s)", err, plframe_strerror(err));
return PLFRAME_EINVAL;
return (plcrash_error_t) PLFRAME_EINVAL;
}
/* Now in unwind_tester; verify that we unwound to the correct IP */

30
Tests/PLCrashAsyncCompactUnwindEncodingTests.m
View File

@@ -110,7 +110,7 @@
plcrash_error_t err;
NSData *mappedImage = [self nativeBinaryFromTestResource: TEST_BINARY];
err = plcrash_nasync_macho_init(&_image, mach_task_self(), [TEST_BINARY UTF8String], [mappedImage bytes]);
err = plcrash_nasync_macho_init(&_image, mach_task_self(), [TEST_BINARY UTF8String], (pl_vm_address_t) [mappedImage bytes]);
STAssertEquals(err, PLCRASH_ESUCCESS, @"Failed to initialize Mach-O parser");
/* Map the unwind section */
@@ -209,7 +209,7 @@
STAssertEquals(res, PLCRASH_ESUCCESS, @"Failed to decode entry");
STAssertEquals(PLCRASH_ASYNC_CFE_ENTRY_TYPE_FRAME_PTR, plcrash_async_cfe_entry_type(&entry), @"Incorrect entry type");
uint32_t reg_ebp_offset = plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t reg_ebp_offset = (uint32_t) plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t reg_count = plcrash_async_cfe_entry_register_count(&entry);
STAssertEquals(reg_ebp_offset, -encoded_reg_ebp_offset, @"Incorrect offset extracted");
STAssertEquals(reg_count, (uint32_t)3, @"Incorrect register count extracted");
@@ -269,7 +269,7 @@
STAssertEquals(res, PLCRASH_ESUCCESS, @"Failed to decode entry");
STAssertEquals(PLCRASH_ASYNC_CFE_ENTRY_TYPE_FRAMELESS_IMMD, plcrash_async_cfe_entry_type(&entry), @"Incorrect entry type");
uint32_t stack_size = plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t stack_size = (uint32_t) plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t reg_count = plcrash_async_cfe_entry_register_count(&entry);
STAssertEquals(stack_size, encoded_stack_size, @"Incorrect stack size decoded");
@@ -314,7 +314,7 @@
STAssertEquals(res, PLCRASH_ESUCCESS, @"Failed to decode entry");
STAssertEquals(PLCRASH_ASYNC_CFE_ENTRY_TYPE_FRAMELESS_INDIRECT, plcrash_async_cfe_entry_type(&entry), @"Incorrect entry type");
uint32_t stack_size = plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t stack_size = (uint32_t) plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t reg_count = plcrash_async_cfe_entry_register_count(&entry);
uint32_t stack_adjust = plcrash_async_cfe_entry_stack_adjustment(&entry);
@@ -354,7 +354,7 @@
STAssertEquals(PLCRASH_ASYNC_CFE_ENTRY_TYPE_DWARF, plcrash_async_cfe_entry_type(&entry), @"Incorrect entry type");
STAssertEquals((plcrash_regnum_t)PLCRASH_REG_INVALID, plcrash_async_cfe_entry_return_address_register(&entry), @"Return address register set");
uint32_t dwarf_offset = plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t dwarf_offset = (uint32_t) plcrash_async_cfe_entry_stack_offset(&entry);
STAssertEquals(dwarf_offset, encoded_dwarf_offset, @"Incorrect dwarf offset decoded");
plcrash_async_cfe_entry_free(&entry);
@@ -426,7 +426,7 @@
STAssertEquals(res, PLCRASH_ESUCCESS, @"Failed to decode entry");
STAssertEquals(PLCRASH_ASYNC_CFE_ENTRY_TYPE_FRAME_PTR, plcrash_async_cfe_entry_type(&entry), @"Incorrect entry type");
uint32_t reg_ebp_offset = plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t reg_ebp_offset = (uint32_t) plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t reg_count = plcrash_async_cfe_entry_register_count(&entry);
STAssertEquals(reg_ebp_offset, -encoded_reg_rbp_offset, @"Incorrect offset extracted");
STAssertEquals(reg_count, (uint32_t)3, @"Incorrect register count extracted");
@@ -471,7 +471,7 @@
STAssertEquals(res, PLCRASH_ESUCCESS, @"Failed to decode entry");
STAssertEquals(PLCRASH_ASYNC_CFE_ENTRY_TYPE_FRAMELESS_IMMD, plcrash_async_cfe_entry_type(&entry), @"Incorrect entry type");
uint32_t stack_size = plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t stack_size = (uint32_t) plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t reg_count = plcrash_async_cfe_entry_register_count(&entry);
STAssertEquals(stack_size, encoded_stack_size, @"Incorrect stack size decoded");
@@ -514,7 +514,7 @@
STAssertEquals(res, PLCRASH_ESUCCESS, @"Failed to decode entry");
STAssertEquals(PLCRASH_ASYNC_CFE_ENTRY_TYPE_FRAMELESS_INDIRECT, plcrash_async_cfe_entry_type(&entry), @"Incorrect entry type");
uint32_t stack_size = plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t stack_size = (uint32_t) plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t reg_count = plcrash_async_cfe_entry_register_count(&entry);
STAssertEquals(stack_size, encoded_stack_size, @"Incorrect stack size decoded");
@@ -552,7 +552,7 @@
STAssertEquals(PLCRASH_ASYNC_CFE_ENTRY_TYPE_DWARF, plcrash_async_cfe_entry_type(&entry), @"Incorrect entry type");
STAssertEquals((plcrash_regnum_t)PLCRASH_REG_INVALID, plcrash_async_cfe_entry_return_address_register(&entry), @"Return address register set");
uint32_t dwarf_offset = plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t dwarf_offset = (uint32_t) plcrash_async_cfe_entry_stack_offset(&entry);
STAssertEquals(dwarf_offset, encoded_dwarf_offset, @"Incorrect dwarf offset decoded");
plcrash_async_cfe_entry_free(&entry);
@@ -573,7 +573,7 @@
STAssertEquals(res, PLCRASH_ESUCCESS, @"Failed to decode entry");
STAssertEquals(PLCRASH_ASYNC_CFE_ENTRY_TYPE_FRAME_PTR, plcrash_async_cfe_entry_type(&entry), @"Incorrect entry type");
int32_t reg_offset = plcrash_async_cfe_entry_stack_offset(&entry);
int32_t reg_offset = (uint32_t) plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t reg_count = plcrash_async_cfe_entry_register_count(&entry);
STAssertEquals(reg_count, (uint32_t)4, @"Incorrect register count extracted");
STAssertEquals(reg_offset, (int32_t)-32, @"Incorrect register offset extracted (wanted -32, got %"PRId32")", reg_offset);
@@ -616,7 +616,7 @@
STAssertEquals(res, PLCRASH_ESUCCESS, @"Failed to decode entry");
STAssertEquals(PLCRASH_ASYNC_CFE_ENTRY_TYPE_FRAMELESS_IMMD, plcrash_async_cfe_entry_type(&entry), @"Incorrect entry type");
uint32_t stack_size = plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t stack_size = (uint32_t) plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t reg_count = plcrash_async_cfe_entry_register_count(&entry);
STAssertEquals(stack_size, encoded_stack_size, @"Incorrect stack size decoded");
@@ -659,7 +659,7 @@
STAssertEquals(PLCRASH_ASYNC_CFE_ENTRY_TYPE_DWARF, plcrash_async_cfe_entry_type(&entry), @"Incorrect entry type");
STAssertEquals((plcrash_regnum_t)PLCRASH_REG_INVALID, plcrash_async_cfe_entry_return_address_register(&entry), @"Return address register set");
uint32_t dwarf_offset = plcrash_async_cfe_entry_stack_offset(&entry);
uint32_t dwarf_offset = (uint32_t) plcrash_async_cfe_entry_stack_offset(&entry);
STAssertEquals(dwarf_offset, encoded_dwarf_offset, @"Incorrect dwarf offset decoded");
plcrash_async_cfe_entry_free(&entry);
@@ -957,7 +957,7 @@
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_cfe_entry_init(&entry, CPU_TYPE_X86_64, encoding), @"Failed to initialize CFE entry");
/* Initialize default thread state */
plcrash_greg_t stack_addr = &stackframe[4]; // rbp
plcrash_greg_t stack_addr = (plcrash_greg_t) &stackframe[4]; // rbp
STAssertEquals(plcrash_async_thread_state_init(&ts, CPU_TYPE_X86_64), PLCRASH_ESUCCESS, @"Failed to initialize thread state");
plcrash_async_thread_state_set_reg(&ts, PLCRASH_REG_FP, stack_addr);
@@ -1081,7 +1081,7 @@
/* Initialize default thread state */
STAssertEquals(plcrash_async_thread_state_init(&ts, CPU_TYPE_X86_64), PLCRASH_ESUCCESS, @"Failed to initialize thread state");
plcrash_async_thread_state_set_reg(&ts, PLCRASH_REG_SP, &stackframe);
plcrash_async_thread_state_set_reg(&ts, PLCRASH_REG_SP, (plcrash_greg_t) &stackframe);
/* Apply */
plcrash_async_thread_state_t nts;
@@ -1148,7 +1148,7 @@
/* Initialize default thread state */
STAssertEquals(plcrash_async_thread_state_init(&ts, CPU_TYPE_X86_64), PLCRASH_ESUCCESS, @"Failed to initialize thread state");
plcrash_async_thread_state_set_reg(&ts, PLCRASH_REG_SP, &stackframe);
plcrash_async_thread_state_set_reg(&ts, PLCRASH_REG_SP, (plcrash_greg_t) &stackframe);
/* Apply */
plcrash_async_thread_state_t nts;

4
Tests/PLCrashAsyncDwarfCFAStateEvaluationTests.mm
View File

@@ -450,10 +450,10 @@ using namespace plcrash::async;
* @param skip The number of valid registers to skip before returning a register. This may be used to fetch
* multiple general purpose registers.
*/
- (uint64_t) findTestDwarfRegister: (plcrash_async_thread_state_t *) ts skip: (NSUInteger) skip {
- (dwarf_cfa_state_regnum_t) findTestDwarfRegister: (plcrash_async_thread_state_t *) ts skip: (NSUInteger) skip {
uint64_t dw;
STAssertTrue(plcrash_async_thread_state_map_reg_to_dwarf(ts, [self findTestRegister: ts skip: skip], &dw), @"Failed to map to dwarf register");
return dw;
return (dwarf_cfa_state_regnum_t) dw;
}
/**

2
Tests/PLCrashAsyncDwarfCIETests.mm
View File

@@ -227,7 +227,7 @@ struct __attribute__((packed)) cie_data {
plcrash_async_mobject_t mobj;
plcrash_error_t err;
_cie_data.cie_version = 9999; // invalid version
_cie_data.cie_version = (uint8_t)9999; // invalid version
err = plcrash_async_mobject_init(&mobj, mach_task_self(), (pl_vm_address_t) &_cie_data, sizeof(_cie_data), true);
STAssertEquals(err, PLCRASH_ESUCCESS, @"Failed to initialize mobj");

2
Tests/PLCrashAsyncImageListTests.m
View File

@@ -72,7 +72,7 @@
plcrash_async_image_t *item = NULL;
plcrash_async_image_list_set_reading(&_list, true);
for (uintptr_t i = 0; i <= 5; i++) {
for (uint32_t i = 0; i <= 5; i++) {
/* Fetch the next item */
item = plcrash_async_image_list_next(&_list, item);
if (i <= 4) {

10
Tests/PLCrashAsyncMObjectTests.m
View File

@@ -177,26 +177,26 @@
/* Map the memory */
plcrash_async_mobject_t mobj;
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_mobject_init(&mobj, mach_task_self(), test_bytes, sizeof(test_bytes), true), @"Failed to initialize mapping");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_mobject_init(&mobj, mach_task_self(), (pl_vm_address_t) test_bytes, sizeof(test_bytes), true), @"Failed to initialize mapping");
/* uint8 */
uint8_t u8;
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_mobject_read_uint8(&mobj, test_bytes-1, 1, &u8), @"Failed to read data");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_mobject_read_uint8(&mobj, (pl_vm_address_t)(test_bytes-1), 1, &u8), @"Failed to read data");
STAssertEquals(u8, (uint8_t) 0x0, @"Incorrect data");
/* uint16 */
uint16_t u16;
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_mobject_read_uint16(&mobj, byteorder, test_bytes-1, 1, &u16), @"Failed to read data");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_mobject_read_uint16(&mobj, byteorder, (pl_vm_address_t) (test_bytes-1), 1, &u16), @"Failed to read data");
STAssertEquals(u16, (uint16_t) 0x0001, @"Incorrect data");
/* uint32 */
uint32_t u32;
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_mobject_read_uint32(&mobj, byteorder, test_bytes-1, 1, &u32), @"Failed to read data");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_mobject_read_uint32(&mobj, byteorder, (pl_vm_address_t) (test_bytes-1), 1, &u32), @"Failed to read data");
STAssertEquals(u32, (uint32_t) 0x00010203, @"Incorrect data");
/* uint64 */
uint64_t u64;
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_mobject_read_uint64(&mobj, byteorder, test_bytes-1, 1, &u64), @"Failed to read data");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_mobject_read_uint64(&mobj, byteorder, (pl_vm_address_t) (test_bytes-1), 1, &u64), @"Failed to read data");
STAssertEquals(u64, (uint64_t) 0x0001020304050607ULL, @"Incorrect data");
/* Clean up */

4
Tests/PLCrashAsyncMachOImageTests.m
View File

@@ -56,7 +56,7 @@
for (uint32_t i = 0; i < _dyld_image_count(); i++) {
if (_dyld_get_image_header(i) == info.dli_fbase) {
vmaddr_slide = _dyld_get_image_vmaddr_slide(i);
text_vmaddr = info.dli_fbase - vmaddr_slide;
text_vmaddr = (uintptr_t) (info.dli_fbase - vmaddr_slide);
found_image = true;
break;
}
@@ -417,7 +417,7 @@ static void testFindSymbol_cb (pl_vm_address_t address, const char *name, void *
/* Perform our symbol lookup */
pl_vm_address_t pc;
plcrash_error_t res = plcrash_async_macho_find_symbol_by_name(&_image, (pl_vm_address_t) dli.dli_sname, &pc);
plcrash_error_t res = plcrash_async_macho_find_symbol_by_name(&_image, (const char *) dli.dli_sname, &pc);
STAssertEquals(res, PLCRASH_ESUCCESS, @"Failed to locate symbol %s", dli.dli_sname);
/* Compare the results */

8
Tests/PLCrashAsyncTests.m
View File

@@ -120,16 +120,16 @@
union test_data dest;
src.u64 = 0xCAFEF00DDEADBEEFULL;
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_task_read_uint64(mach_task_self(), byteorder, &src, 0, &dest.u64), @"Failed to read value");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_task_read_uint64(mach_task_self(), byteorder, (pl_vm_address_t) &src, 0, &dest.u64), @"Failed to read value");
STAssertEquals(byteorder->swap64(dest.u64), src.u64, @"Incorrect value read");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_task_read_uint32(mach_task_self(), byteorder, &src, 0, &dest.u32), @"Failed to read value");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_task_read_uint32(mach_task_self(), byteorder, (pl_vm_address_t) &src, 0, &dest.u32), @"Failed to read value");
STAssertEquals(byteorder->swap32(dest.u32), src.u32, @"Incorrect value read");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_task_read_uint16(mach_task_self(), byteorder, &src, 0, &dest.u16), @"Failed to read value");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_task_read_uint16(mach_task_self(), byteorder, (pl_vm_address_t) &src, 0, &dest.u16), @"Failed to read value");
STAssertEquals(byteorder->swap16(dest.u16), src.u16, @"Incorrect value read");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_task_read_uint8(mach_task_self(), &src, 0, &dest.u8), @"Failed to read value");
STAssertEquals(PLCRASH_ESUCCESS, plcrash_async_task_read_uint8(mach_task_self(), (pl_vm_address_t) &src, 0, &dest.u8), @"Failed to read value");
STAssertEquals(dest.u8, src.u8, @"Incorrect value read");
}

2
Tests/PLCrashFrameCompactUnwindTests.m
View File

@@ -69,7 +69,7 @@
plframe_error_t err;
plcrash_async_thread_state_clear_all_regs(&frame.thread_state);
plcrash_async_thread_state_set_reg(&frame.thread_state, PLCRASH_REG_IP, NULL);
plcrash_async_thread_state_set_reg(&frame.thread_state, PLCRASH_REG_IP, (plcrash_greg_t) NULL);
err = plframe_cursor_read_compact_unwind(mach_task_self(), &_image_list, &frame, NULL, &next);
STAssertEquals(err, PLFRAME_ENOTSUP, @"Unexpected result for a frame missing a valid image");

2
Tests/PLCrashFrameDWARFUnwindTests.m
View File

@@ -71,7 +71,7 @@
plframe_error_t err;
plcrash_async_thread_state_clear_all_regs(&frame.thread_state);
plcrash_async_thread_state_set_reg(&frame.thread_state, PLCRASH_REG_IP, NULL);
plcrash_async_thread_state_set_reg(&frame.thread_state, PLCRASH_REG_IP, (plcrash_greg_t) NULL);
err = plframe_cursor_read_dwarf_unwind(mach_task_self(), &_image_list, &frame, NULL, &next);
STAssertEquals(err, PLFRAME_ENOTSUP, @"Unexpected result for a frame missing a valid image");

12
Tests/PLCrashFrameStackUnwindTests.m
View File

@@ -64,9 +64,9 @@ struct stack_frame {
- (void) testNULLFrame {
/* Set up test stack */
struct stack_frame frames[] = {
{ .fp = &frames[1], .pc = 0x1 },
{ .fp = &frames[2], .pc = 0x2 },
{ .fp = 0x0, .pc = 0x3 },
{ .fp = (uintptr_t) &frames[1], .pc = 0x1 },
{ .fp = (uintptr_t) &frames[2], .pc = 0x2 },
{ .fp = (uintptr_t) 0x0, .pc = 0x3 },
};
size_t frame_count = sizeof(frames) / sizeof(frames[0]);
@@ -112,9 +112,9 @@ struct stack_frame {
- (void) testStackDirection {
/* Set up test stack */
struct stack_frame frames[] = {
{ .fp = &frames[1], .pc = 0x1 },
{ .fp = &frames[2], .pc = 0x2 },
{ .fp = &frames[0], .pc = 0x3 },
{ .fp = (uintptr_t) &frames[1], .pc = 0x1 },
{ .fp = (uintptr_t) &frames[2], .pc = 0x2 },
{ .fp = (uintptr_t) &frames[0], .pc = 0x3 },
};
size_t frame_count = sizeof(frames) / sizeof(frames[0]);

2
Tests/PLCrashLogWriterTests.m
View File

@@ -328,7 +328,7 @@
/* Initialize the image list */
plcrash_nasync_image_list_init(&image_list, mach_task_self());
for (uint32_t i = 0; i < _dyld_image_count(); i++)
plcrash_nasync_image_list_append(&image_list, _dyld_get_image_header(i), _dyld_get_image_name(i));
plcrash_nasync_image_list_append(&image_list, (pl_vm_address_t) _dyld_get_image_header(i), _dyld_get_image_name(i));
/* Initialze faux crash data */
plcrash_log_signal_info_t info;