INSTALL_HDR_PATH = $(top_srcdir)/usr
 LINUX_HDR_PATH = $(INSTALL_HDR_PATH)/include/
 LINUX_TOOL_INCLUDE = $(top_srcdir)/tools/include
-CFLAGS += -O2 -g -std=gnu99 -fno-stack-protector -fno-PIE -I$(LINUX_TOOL_INCLUDE) -I$(LINUX_HDR_PATH) -Iinclude -I$(<D) -Iinclude/$(UNAME_M) -I..
+CFLAGS += -Wall -Wstrict-prototypes -Wuninitialized -O2 -g -std=gnu99 \
+       -fno-stack-protector -fno-PIE -I$(LINUX_TOOL_INCLUDE) \
+       -I$(LINUX_HDR_PATH) -Iinclude -I$(<D) -Iinclude/$(UNAME_M) -I..
 
 no-pie-option := $(call try-run, echo 'int main() { return 0; }' | \
         $(CC) -Werror $(KBUILD_CPPFLAGS) $(CC_OPTION_CFLAGS) -no-pie -x c - -o "$$TMP", -no-pie)
 
        while (!READ_ONCE(host_quit)) {
                /* Let the guest dirty the random pages */
                ret = _vcpu_run(vm, VCPU_ID);
+               TEST_ASSERT(ret == 0, "vcpu_run failed: %d\n", ret);
                if (get_ucall(vm, VCPU_ID, &uc) == UCALL_SYNC) {
                        pages_count += TEST_PAGES_PER_LOOP;
                        generate_random_array(guest_array, TEST_PAGES_PER_LOOP);
        unsigned long interval = TEST_HOST_LOOP_INTERVAL;
        bool mode_selected = false;
        uint64_t phys_offset = 0;
-       unsigned int mode, host_ipa_limit;
+       unsigned int mode;
        int opt, i;
+#ifdef __aarch64__
+       unsigned int host_ipa_limit;
+#endif
 
 #ifdef USE_CLEAR_DIRTY_LOG
        if (!kvm_check_cap(KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2)) {
 
                          int perm, unsigned long type)
 {
        struct kvm_vm *vm;
-       int kvm_fd;
 
        vm = calloc(1, sizeof(*vm));
        TEST_ASSERT(vm != NULL, "Insufficient Memory");
        uint32_t flags)
 {
        int ret;
-       unsigned long pmem_size = 0;
        struct userspace_mem_region *region;
        size_t huge_page_size = KVM_UTIL_PGS_PER_HUGEPG * vm->page_size;
 
 int _vcpu_sregs_set(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_sregs *sregs)
 {
        struct vcpu *vcpu = vcpu_find(vm, vcpuid);
-       int ret;
 
        TEST_ASSERT(vcpu != NULL, "vcpu not found, vcpuid: %u", vcpuid);
 
 
 
 void virt_pgd_alloc(struct kvm_vm *vm, uint32_t pgd_memslot)
 {
-       int rc;
-
        TEST_ASSERT(vm->mode == VM_MODE_P52V48_4K, "Attempt to use "
                "unknown or unsupported guest mode, mode: 0x%x", vm->mode);
 
        struct pageDirectoryPointerEntry *pdpe;
        struct pageDirectoryEntry *pde;
        struct pageTableEntry *pte;
-       void *hva;
 
        TEST_ASSERT(vm->mode == VM_MODE_P52V48_4K, "Attempt to use "
                "unknown or unsupported guest mode, mode: 0x%x", vm->mode);
 unmapped_gva:
        TEST_ASSERT(false, "No mapping for vm virtual address, "
                    "gva: 0x%lx", gva);
+       exit(EXIT_FAILURE);
 }
 
 static void kvm_setup_gdt(struct kvm_vm *vm, struct kvm_dtable *dt, int gdt_memslot,
 
        while (1) {
                rc = _vcpu_run(vm, VCPU_ID);
 
+               TEST_ASSERT(rc == 0, "vcpu_run failed: %d\n", rc);
                TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
                            "Unexpected exit reason: %u (%s),\n",
                            run->exit_reason,
 
 
 #define VCPU_ID                5
 
-static bool have_nested_state;
-
 void l2_guest_code(void)
 {
        GUEST_SYNC(6);
 
 int main(int argc, char *argv[])
 {
-       struct vmx_pages *vmx_pages = NULL;
        vm_vaddr_t vmx_pages_gva = 0;
 
        struct kvm_regs regs1, regs2;
                 .args[0] = (unsigned long)&evmcs_ver
        };
 
-       struct kvm_cpuid_entry2 *entry = kvm_get_supported_cpuid_entry(1);
-
        /* Create VM */
        vm = vm_create_default(VCPU_ID, 0, guest_code);
 
 
        vcpu_regs_get(vm, VCPU_ID, ®s1);
 
-       vmx_pages = vcpu_alloc_vmx(vm, &vmx_pages_gva);
+       vcpu_alloc_vmx(vm, &vmx_pages_gva);
        vcpu_args_set(vm, VCPU_ID, 1, vmx_pages_gva);
 
        for (stage = 1;; stage++) {
 
 {
        int nent = 20; /* should be enough */
        static struct kvm_cpuid2 *cpuid;
-       int ret;
 
        cpuid = malloc(sizeof(*cpuid) + nent * sizeof(struct kvm_cpuid_entry2));
 
 
 int main(int argc, char *argv[])
 {
        struct kvm_vm *vm;
-       struct kvm_run *state;
        int rv;
        uint64_t msr_platform_info;
 
 
 
 int main(int argc, char *argv[])
 {
-       struct vmx_pages *vmx_pages = NULL;
        vm_vaddr_t vmx_pages_gva = 0;
 
        struct kvm_regs regs;
        vcpu_set_msr(vm, VCPU_ID, MSR_IA32_SMBASE, SMRAM_GPA);
 
        if (kvm_check_cap(KVM_CAP_NESTED_STATE)) {
-               vmx_pages = vcpu_alloc_vmx(vm, &vmx_pages_gva);
+               vcpu_alloc_vmx(vm, &vmx_pages_gva);
                vcpu_args_set(vm, VCPU_ID, 1, vmx_pages_gva);
        } else {
                printf("will skip SMM test with VMX enabled\n");
 
 
 #define VCPU_ID                5
 
-static bool have_nested_state;
-
 void l2_guest_code(void)
 {
        GUEST_SYNC(6);
 
 int main(int argc, char *argv[])
 {
-       struct vmx_pages *vmx_pages = NULL;
        vm_vaddr_t vmx_pages_gva = 0;
 
        struct kvm_regs regs1, regs2;
        struct ucall uc;
        int stage;
 
-       struct kvm_cpuid_entry2 *entry = kvm_get_supported_cpuid_entry(1);
-
        /* Create VM */
        vm = vm_create_default(VCPU_ID, 0, guest_code);
        vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid());
        vcpu_regs_get(vm, VCPU_ID, ®s1);
 
        if (kvm_check_cap(KVM_CAP_NESTED_STATE)) {
-               vmx_pages = vcpu_alloc_vmx(vm, &vmx_pages_gva);
+               vcpu_alloc_vmx(vm, &vmx_pages_gva);
                vcpu_args_set(vm, VCPU_ID, 1, vmx_pages_gva);
        } else {
                printf("will skip nested state checks\n");
 
 {
 #define L2_GUEST_STACK_SIZE 64
        unsigned long l2_guest_stack[L2_GUEST_STACK_SIZE];
-       uint32_t control;
-       uintptr_t save_cr3;
 
        GUEST_ASSERT(prepare_for_vmx_operation(vmx_pages));
        GUEST_ASSERT(load_vmcs(vmx_pages));
 
 int main(int argc, char *argv[])
 {
-       struct vmx_pages *vmx_pages;
        vm_vaddr_t vmx_pages_gva;
        struct kvm_cpuid_entry2 *entry = kvm_get_supported_cpuid_entry(1);
 
        vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid());
 
        /* Allocate VMX pages and shared descriptors (vmx_pages). */
-       vmx_pages = vcpu_alloc_vmx(vm, &vmx_pages_gva);
+       vcpu_alloc_vmx(vm, &vmx_pages_gva);
        vcpu_args_set(vm, VCPU_ID, 1, vmx_pages_gva);
 
        for (;;) {
 
        GUEST_DONE();
 }
 
-void report(int64_t val)
+static void report(int64_t val)
 {
        printf("IA32_TSC_ADJUST is %ld (%lld * TSC_ADJUST_VALUE + %lld).\n",
               val, val / TSC_ADJUST_VALUE, val % TSC_ADJUST_VALUE);
 
 int main(int argc, char *argv[])
 {
-       struct vmx_pages *vmx_pages;
        vm_vaddr_t vmx_pages_gva;
        struct kvm_cpuid_entry2 *entry = kvm_get_supported_cpuid_entry(1);
 
        vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid());
 
        /* Allocate VMX pages and shared descriptors (vmx_pages). */
-       vmx_pages = vcpu_alloc_vmx(vm, &vmx_pages_gva);
+       vcpu_alloc_vmx(vm, &vmx_pages_gva);
        vcpu_args_set(vm, VCPU_ID, 1, vmx_pages_gva);
 
        for (;;) {