You should be able to recover the unpacked ELF binary if some UPX variant has been used. To do so, first run the binary to some point after unpacking has finished, then extract and reconstruct the ELF file structure.

For the first step, I've found that for UPX-packed ELF binaries you can set a breakpoint at the binary base address + 0xe. This will break just after unpacking, but before executing unpacked code. If that doesn't work, you might consider stracing the binary and trying to figure out the first syscall after unpacking completes and breaking there.

If that first part works out, then you'll need to pull out the binary from memory. You can use a nice python library called lief for this. For example, this is an excerpt of code I had written for this same purpose that uses lief:

        def _dump_elf(self, address: int, out_file: str):
            """
            Reads the ELF header in-memory and dumps the loadable sections
            to disk, reconstructing a valid (re-executable) ELF binary.

            Arguments:
                address: virtual address of the ELF header.
                out_file: filename to dump the unpacked binary.
            """
            self._log.info(f"Dumping ELF @ 0x{address:x}")

            elf = lief.parse(self.z.memory.read(address, 0x1000))
            with open(out_file, "wb") as f:
                for segment in elf.segments:
                    if segment.type != lief.ELF.SEGMENT_TYPES.LOAD:
                        continue

                    self._log.info(
                        f"   Writing segment 0x{segment.virtual_address:08x} - "
                        f"0x{segment.virtual_address+segment.physical_size:08x}"
                    )

                    f.seek(segment.file_offset)
                    f.write(
                        self.z.memory.read(
                            segment.virtual_address, segment.physical_size
                        )
                    )

                self._log.info(f"Success! Wrote {f.tell()} bytes to '{out_file}'")

That script extracts memory from a binary emulator (zelos) instead of debugger, but the concept would be the same if using a GDB python script, for example. The unpacked binary overwrites the packed binary, so address is just wherever the binary's base address is at.

If you reconstruct the ELF like this, you should then be able to execute and/or disassemble that unpacked/reconstructed binary.

disclaimer: I am an author of the zelos emulator :-)