return (ti->local_flags & flags) != 0;
 }
 
-#ifdef CONFIG_PPC64
+#ifdef CONFIG_COMPAT
 #define is_32bit_task()        (test_thread_flag(TIF_32BIT))
 #else
-#define is_32bit_task()        (1)
+#define is_32bit_task()        (IS_ENABLED(CONFIG_PPC32))
 #endif
 
 #if defined(CONFIG_PPC64)
 
 endif
 
 obj-y                          := cputable.o syscalls.o \
-                                  irq.o align.o signal_32.o pmc.o vdso.o \
+                                  irq.o align.o signal_$(BITS).o pmc.o vdso.o \
                                   process.o systbl.o idle.o \
                                   signal.o sysfs.o cacheinfo.o time.o \
                                   prom.o traps.o setup-common.o \
                                   udbg.o misc.o io.o misc_$(BITS).o \
                                   of_platform.o prom_parse.o
 obj-y                          += ptrace/
-obj-$(CONFIG_PPC64)            += setup_64.o sys_ppc32.o signal_64.o \
+obj-$(CONFIG_PPC64)            += setup_64.o \
                                   paca.o nvram_64.o firmware.o note.o \
                                   syscall_64.o
+obj-$(CONFIG_COMPAT)           += sys_ppc32.o signal_32.o
 obj-$(CONFIG_VDSO32)           += vdso32/
 obj-$(CONFIG_PPC_WATCHDOG)     += watchdog.o
 obj-$(CONFIG_HAVE_HW_BREAKPOINT)       += hw_breakpoint.o
 
 SYS_CALL_TABLE:
        .tc sys_call_table[TC],sys_call_table
 
+#ifdef CONFIG_COMPAT
 COMPAT_SYS_CALL_TABLE:
        .tc compat_sys_call_table[TC],compat_sys_call_table
+#endif
 
 /* This value is used to mark exception frames on the stack. */
 exception_marker:
 
 CFLAGS_ptrace-view.o           += -DUTS_MACHINE='"$(UTS_MACHINE)"'
 
 obj-y                          += ptrace.o ptrace-view.o
-obj-$(CONFIG_PPC64)            += ptrace32.o
+obj-$(CONFIG_COMPAT)           += ptrace32.o
 obj-$(CONFIG_VSX)              += ptrace-vsx.o
 ifneq ($(CONFIG_VSX),y)
 obj-y                          += ptrace-novsx.o
 
        sigset_t *oldset = sigmask_to_save();
        struct ksignal ksig = { .sig = 0 };
        int ret;
-       int is32 = is_32bit_task();
 
        BUG_ON(tsk != current);
 
 
        rseq_signal_deliver(&ksig, tsk->thread.regs);
 
-       if (is32) {
+       if (is_32bit_task()) {
                if (ksig.ka.sa.sa_flags & SA_SIGINFO)
                        ret = handle_rt_signal32(&ksig, oldset, tsk);
                else
 
                                   long r6, long r7, long r8,
                                   unsigned long r0, struct pt_regs *regs)
 {
-       unsigned long ti_flags;
        syscall_fn f;
 
        if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG))
 
        local_irq_enable();
 
-       ti_flags = current_thread_info()->flags;
-       if (unlikely(ti_flags & _TIF_SYSCALL_DOTRACE)) {
+       if (unlikely(current_thread_info()->flags & _TIF_SYSCALL_DOTRACE)) {
                /*
                 * We use the return value of do_syscall_trace_enter() as the
                 * syscall number. If the syscall was rejected for any reason
        /* May be faster to do array_index_nospec? */
        barrier_nospec();
 
-       if (unlikely(ti_flags & _TIF_32BIT)) {
+       if (unlikely(is_32bit_task())) {
                f = (void *)compat_sys_call_table[r0];
 
                r3 &= 0x00000000ffffffffULL;
 
                if (sys_call_table[i] != sys_ni_syscall)
                        vdso_data->syscall_map_64[i >> 5] |=
                                0x80000000UL >> (i & 0x1f);
-               if (compat_sys_call_table[i] != sys_ni_syscall)
+               if (IS_ENABLED(CONFIG_COMPAT) &&
+                   compat_sys_call_table[i] != sys_ni_syscall)
                        vdso_data->syscall_map_32[i >> 5] |=
                                0x80000000UL >> (i & 0x1f);
 #else /* CONFIG_PPC64 */
 
 #include <asm/sigcontext.h>
 #include <asm/ucontext.h>
 #include <asm/vdso.h>
-#ifdef CONFIG_PPC64
+#ifdef CONFIG_COMPAT
 #include "../kernel/ppc32.h"
 #endif
 #include <asm/pte-walk.h>
 
 #endif /* CONFIG_PPC64 */
 
+#if defined(CONFIG_PPC32) || defined(CONFIG_COMPAT)
 /*
  * On 32-bit we just access the address and let hash_page create a
  * HPTE if necessary, so there is no need to fall back to reading
                sp = next_sp;
        }
 }
+#else /* 32bit */
+static void perf_callchain_user_32(struct perf_callchain_entry_ctx *entry,
+                                  struct pt_regs *regs)
+{}
+#endif /* 32bit */
 
 void
 perf_callchain_user(struct perf_callchain_entry_ctx *entry, struct pt_regs *regs)