Mirror
/
upx
mirror of https://github.com/upx/upx.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

clang-10 requires the use of 'override' 

Discovered during gitlab auto-build for https://github.com/upx/upx/issues/595
	modified:   Makefile
	modified:   p_armpe.h
	modified:   p_djgpp2.h
	modified:   p_lx_elf.h
	modified:   p_lx_exc.h
	modified:   p_lx_interp.h
	modified:   p_lx_sh.h
	modified:   p_mach.h
	modified:   p_ps1.h
	modified:   p_tmt.h
	modified:   p_unix.h
	modified:   p_vmlinx.h
	modified:   p_vmlinz.h
	modified:   p_w32pe.h
	modified:   p_w64pep.h
	modified:   pefile.h
This commit is contained in:
John Reiser 2022-09-26 16:31:49 -07:00 committed by Markus F.X.J. Oberhumer
parent 2cfa4c1eb7
commit ec33109b22
12 changed files with 456 additions and 453 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/Makefile
View File

@ -116,7 +116,10 @@ mf.CXXFLAGS += -funsigned-char
mf.CXXFLAGS += -fno-tree-vectorize
mf.CXXFLAGS += $(CXXFLAGS_SANITIZE)
mf.CXXFLAGS += -Wall -Wextra -Wcast-align -Wcast-qual -Wmissing-declarations -Wpointer-arith -Wshadow -Wvla -Wwrite-strings
# clang-10 requires 'override'. gcc-12 does not, but "g++ -Wsuggest-override" tells you where
##mf.CXXFLAGS += -Wsuggest-override
mf.CXXFLAGS += $(CXXFLAGS_WERROR)
# rules

42
src/p_armpe.h
View File

@ -41,36 +41,36 @@ class PackArmPe : public PeFile32
public:
PackArmPe(InputFile *f);
virtual ~PackArmPe();
virtual int getFormat() const { return UPX_F_WINCE_ARM_PE; }
virtual const char *getName() const { return "arm/pe"; }
virtual const char *getFullName(const options_t *) const { return "arm-wince.pe"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual void defineFilterSymbols(const Filter *) {}
virtual int getFormat() const override { return UPX_F_WINCE_ARM_PE; }
virtual const char *getName() const override { return "arm/pe"; }
virtual const char *getFullName(const options_t *) const override { return "arm-wince.pe"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
virtual void defineFilterSymbols(const Filter *) override {}
virtual bool handleForceOption();
virtual bool handleForceOption() override;
virtual void callCompressWithFilters(Filter &, int filter_strategy,
unsigned ih_codebase);
unsigned ih_codebase) override;
virtual void defineSymbols(unsigned ncsection, unsigned upxsection,
unsigned sizeof_oh, unsigned isize_isplit,
unsigned s1addr);
virtual void addNewRelocations(Reloc &, unsigned upxsection);
virtual unsigned getProcessImportParam(unsigned upxsection);
virtual void setOhDataBase(const pe_section_t *osection);
virtual void setOhHeaderSize(const pe_section_t *osection);
virtual void pack(OutputFile *fo);
unsigned s1addr) override;
virtual void addNewRelocations(Reloc &, unsigned upxsection) override;
virtual unsigned getProcessImportParam(unsigned upxsection) override;
virtual void setOhDataBase(const pe_section_t *osection) override;
virtual void setOhHeaderSize(const pe_section_t *osection) override;
virtual void pack(OutputFile *fo) override;
virtual bool canPack();
virtual bool canPack() override;
protected:
virtual void buildLoader(const Filter *ft);
virtual Linker* newLinker() const;
virtual void buildLoader(const Filter *ft) override;
virtual Linker* newLinker() const override;
virtual const char *kernelDll() const { return "COREDLL.dll"; }
virtual void processImports2(unsigned, unsigned);
virtual void addStubImports();
virtual const char *kernelDll() const override { return "COREDLL.dll"; }
virtual void processImports2(unsigned, unsigned) override;
virtual void addStubImports() override;
virtual void processTls(Interval *);
virtual void processTls(Interval *) override;
bool use_thumb_stub;
};

270
src/p_lx_elf.h
View File

@ -41,19 +41,19 @@ public:
virtual ~PackLinuxElf();
/*virtual void buildLoader(const Filter *);*/
virtual int getVersion() const override { return 14; } // upx-3.96 cannot upack, for instance
virtual bool canUnpackVersion(int version) const { return (version >= 11); }
virtual int canUnpack() { return super::canUnpack(); }
virtual bool canUnpackVersion(int version) const override { return (version >= 11); }
virtual int canUnpack() override { return super::canUnpack(); }
protected:
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getCompressionMethods(int method, int level) const override;
// All other virtual functions in this class must be pure virtual
// because they depend on Elf32 or Elf64 data structures, which differ.
virtual void pack1(OutputFile *, Filter &) = 0; // generate executable header
virtual int pack2(OutputFile *, Filter &) = 0; // append compressed data
virtual off_t pack3(OutputFile *, Filter &) = 0; // append loader
//virtual void pack4(OutputFile *, Filter &) = 0; // append pack header
virtual void pack1(OutputFile *, Filter &) override = 0; // generate executable header
virtual int pack2(OutputFile *, Filter &) override = 0; // append compressed data
virtual off_t pack3(OutputFile *, Filter &) override = 0; // append loader
//virtual void pack4(OutputFile *, Filter &) override = 0; // append pack header
virtual void generateElfHdr(
OutputFile *,
@ -62,7 +62,7 @@ protected:
) = 0;
virtual void defineSymbols(Filter const *);
virtual void addStubEntrySections(Filter const *);
virtual void unpack(OutputFile *fo);
virtual void unpack(OutputFile *fo) override;
unsigned old_data_off, old_data_len; // un_shlib
virtual upx_uint64_t elf_unsigned_dynamic(unsigned) const = 0;
@ -122,8 +122,8 @@ public:
protected:
virtual void PackLinuxElf32help1(InputFile *f);
virtual int checkEhdr(Elf32_Ehdr const *ehdr) const;
virtual bool canPack();
virtual int canUnpack();
virtual bool canPack() override;
virtual int canUnpack() override;
// These ARM routines are essentially common to big/little endian,
// but the class hierarchy splits after this class.
@ -131,11 +131,11 @@ protected:
virtual void ARM_updateLoader(OutputFile *);
virtual int ARM_is_QNX(void);
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual int pack2(OutputFile *, Filter &); // append compressed data
virtual off_t pack3(OutputFile *, Filter &); // append loader
virtual void pack4(OutputFile *, Filter &); // append pack header
virtual void unpack(OutputFile *fo);
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual int pack2(OutputFile *, Filter &) override; // append compressed data
virtual off_t pack3(OutputFile *, Filter &) override; // append loader
virtual void pack4(OutputFile *, Filter &) override; // append pack header
virtual void unpack(OutputFile *fo) override;
virtual void unRel32(unsigned dt_rel, Elf32_Rel *rel0, unsigned relsz,
MemBuffer &membuf, unsigned const load_off, OutputFile *fo);
@ -143,8 +143,8 @@ protected:
OutputFile *,
void const *proto,
unsigned const brka
);
virtual void defineSymbols(Filter const *);
) override;
virtual void defineSymbols(Filter const *) override;
virtual void buildLinuxLoader(
upx_byte const *const proto, // assembly-only sections
unsigned const szproto,
@ -153,8 +153,8 @@ protected:
Filter const *ft
);
virtual off_t getbrk(const Elf32_Phdr *phdr, int e_phnum) const;
virtual void patchLoader();
virtual void updateLoader(OutputFile *fo);
virtual void patchLoader() override;
virtual void updateLoader(OutputFile *fo) override;
virtual unsigned find_LOAD_gap(Elf32_Phdr const *const phdri, unsigned const k,
unsigned const e_phnum);
virtual off_t getbase(const Elf32_Phdr *phdr, int e_phnum) const;
@ -171,7 +171,7 @@ protected:
void invert_pt_dynamic(Elf32_Dyn const *, unsigned dt_filesz);
void const *elf_find_dynamic(unsigned) const;
Elf32_Dyn const *elf_has_dynamic(unsigned) const;
virtual upx_uint64_t elf_unsigned_dynamic(unsigned) const;
virtual upx_uint64_t elf_unsigned_dynamic(unsigned) const override;
virtual int adjABS(Elf32_Sym *sym, unsigned delta);
char const *get_str_name(unsigned st_name, unsigned symnum) const;
@ -265,14 +265,14 @@ public:
protected:
virtual void PackLinuxElf64help1(InputFile *f);
virtual int checkEhdr(Elf64_Ehdr const *ehdr) const;
virtual bool canPack();
virtual int canUnpack();
virtual bool canPack() override;
virtual int canUnpack() override;
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual int pack2(OutputFile *, Filter &); // append compressed data
virtual off_t pack3(OutputFile *, Filter &); // append loader
virtual void pack4(OutputFile *, Filter &); // append pack header
virtual void unpack(OutputFile *fo);
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual int pack2(OutputFile *, Filter &) override; // append compressed data
virtual off_t pack3(OutputFile *, Filter &) override; // append loader
virtual void pack4(OutputFile *, Filter &) override; // append pack header
virtual void unpack(OutputFile *fo) override;
virtual void un_shlib_1(
OutputFile *const fo,
MemBuffer &o_elfhdrs,
@ -297,8 +297,8 @@ protected:
OutputFile *,
void const *proto,
unsigned const brka
);
virtual void defineSymbols(Filter const *);
) override;
virtual void defineSymbols(Filter const *) override;
virtual void buildLinuxLoader(
upx_byte const *const proto, // assembly-only sections
unsigned const szproto,
@ -307,8 +307,8 @@ protected:
Filter const *ft
);
virtual off_t getbrk(const Elf64_Phdr *phdr, int e_phnum) const;
virtual void patchLoader();
virtual void updateLoader(OutputFile *fo);
virtual void patchLoader() override;
virtual void updateLoader(OutputFile *fo) override;
virtual unsigned find_LOAD_gap(Elf64_Phdr const *const phdri, unsigned const k,
unsigned const e_phnum);
bool calls_crt1(Elf64_Rela const *rela, int sz);
@ -323,7 +323,7 @@ protected:
void invert_pt_dynamic(Elf64_Dyn const *, upx_uint64_t dt_filesz);
void const *elf_find_dynamic(unsigned) const;
Elf64_Dyn const *elf_has_dynamic(unsigned) const;
virtual upx_uint64_t elf_unsigned_dynamic(unsigned) const;
virtual upx_uint64_t elf_unsigned_dynamic(unsigned) const override;
virtual int adjABS(Elf64_Sym *sym, unsigned delta);
char const *get_str_name(unsigned st_name, unsigned symnum) const;
@ -453,15 +453,15 @@ class PackLinuxElf64amd : public PackLinuxElf64Le
public:
PackLinuxElf64amd(InputFile *f);
virtual ~PackLinuxElf64amd();
virtual int getFormat() const { return UPX_F_LINUX_ELF64_AMD; }
virtual const char *getName() const { return "linux/amd64"; }
virtual const char *getFullName(const options_t *) const { return "amd64-linux.elf"; }
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_LINUX_ELF64_AMD; }
virtual const char *getName() const override { return "linux/amd64"; }
virtual const char *getFullName(const options_t *) const override { return "amd64-linux.elf"; }
virtual const int *getFilters() const override;
protected:
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void buildLoader(const Filter *);
virtual Linker* newLinker() const;
virtual void defineSymbols(Filter const *);
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *) override;
virtual Linker* newLinker() const override;
virtual void defineSymbols(Filter const *) override;
};
class PackLinuxElf64arm : public PackLinuxElf64Le
@ -470,15 +470,15 @@ class PackLinuxElf64arm : public PackLinuxElf64Le
public:
PackLinuxElf64arm(InputFile *f);
virtual ~PackLinuxElf64arm();
virtual int getFormat() const { return UPX_F_LINUX_ELF64_ARM; }
virtual const char *getName() const { return "linux/arm64"; }
virtual const char *getFullName(const options_t *) const { return "arm64-linux.elf"; }
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_LINUX_ELF64_ARM; }
virtual const char *getName() const override { return "linux/arm64"; }
virtual const char *getFullName(const options_t *) const override { return "arm64-linux.elf"; }
virtual const int *getFilters() const override;
protected:
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void buildLoader(const Filter *);
virtual Linker* newLinker() const;
virtual void defineSymbols(Filter const *);
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *) override;
virtual Linker* newLinker() const override;
virtual void defineSymbols(Filter const *) override;
};
@ -492,14 +492,14 @@ class PackLinuxElf32ppc : public PackLinuxElf32Be
public:
PackLinuxElf32ppc(InputFile *f);
virtual ~PackLinuxElf32ppc();
virtual int getFormat() const { return UPX_F_LINUX_ELFPPC32; }
virtual const char *getName() const { return "linux/ppc32"; }
virtual const char *getFullName(const options_t *) const { return "powerpc-linux.elf"; }
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_LINUX_ELFPPC32; }
virtual const char *getName() const override { return "linux/ppc32"; }
virtual const char *getFullName(const options_t *) const override { return "powerpc-linux.elf"; }
virtual const int *getFilters() const override;
protected:
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void buildLoader(const Filter *);
virtual Linker* newLinker() const;
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *) override;
virtual Linker* newLinker() const override;
};
/*************************************************************************
@ -512,16 +512,16 @@ class PackLinuxElf64ppcle : public PackLinuxElf64Le
public:
PackLinuxElf64ppcle(InputFile *f);
virtual ~PackLinuxElf64ppcle();
virtual int getFormat() const { return UPX_F_LINUX_ELFPPC64LE; }
virtual const char *getName() const { return "linux/ppc64le"; }
virtual const char *getFullName(const options_t *) const { return "powerpc64le-linux.elf"; }
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_LINUX_ELFPPC64LE; }
virtual const char *getName() const override { return "linux/ppc64le"; }
virtual const char *getFullName(const options_t *) const override { return "powerpc64le-linux.elf"; }
virtual const int *getFilters() const override;
protected:
unsigned lg2_page; // log2(PAGE_SIZE)
unsigned page_size; // 1u<<lg2_page
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void buildLoader(const Filter *);
virtual Linker* newLinker() const;
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *) override;
virtual Linker* newLinker() const override;
};
@ -531,16 +531,16 @@ class PackLinuxElf64ppc : public PackLinuxElf64Be
public:
PackLinuxElf64ppc(InputFile *f);
virtual ~PackLinuxElf64ppc();
virtual int getFormat() const { return UPX_F_LINUX_ELFPPC64; }
virtual const char *getName() const { return "linux/ppc64"; }
virtual const char *getFullName(const options_t *) const { return "powerpc64-linux.elf"; }
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_LINUX_ELFPPC64; }
virtual const char *getName() const override { return "linux/ppc64"; }
virtual const char *getFullName(const options_t *) const override { return "powerpc64-linux.elf"; }
virtual const int *getFilters() const override;
protected:
unsigned lg2_page; // log2(PAGE_SIZE)
unsigned page_size; // 1u<<lg2_page
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void buildLoader(const Filter *);
virtual Linker* newLinker() const;
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *) override;
virtual Linker* newLinker() const override;
};
@ -554,19 +554,19 @@ class PackLinuxElf32x86 : public PackLinuxElf32Le
public:
PackLinuxElf32x86(InputFile *f);
virtual ~PackLinuxElf32x86();
virtual int getFormat() const { return UPX_F_LINUX_ELF_i386; }
virtual const char *getName() const { return "linux/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-linux.elf"; }
virtual const int *getFilters() const;
virtual int canUnpack();
virtual int getFormat() const override { return UPX_F_LINUX_ELF_i386; }
virtual const char *getName() const override { return "linux/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-linux.elf"; }
virtual const int *getFilters() const override;
virtual int canUnpack() override;
protected:
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *);
virtual void addStubEntrySections(Filter const *);
virtual Linker* newLinker() const;
virtual void defineSymbols(Filter const *);
virtual void buildLoader(const Filter *) override;
virtual void addStubEntrySections(Filter const *) override;
virtual Linker* newLinker() const override;
virtual void defineSymbols(Filter const *) override;
};
class PackBSDElf32x86 : public PackLinuxElf32x86
@ -575,14 +575,14 @@ class PackBSDElf32x86 : public PackLinuxElf32x86
public:
PackBSDElf32x86(InputFile *f);
virtual ~PackBSDElf32x86();
virtual int getFormat() const = 0;
virtual const char *getName() const = 0;
virtual const char *getFullName(const options_t *) const = 0;
virtual int getFormat() const override = 0;
virtual const char *getName() const override = 0;
virtual const char *getFullName(const options_t *) const override = 0;
protected:
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *);
virtual void buildLoader(const Filter *) override;
};
class PackFreeBSDElf32x86 : public PackBSDElf32x86
@ -591,9 +591,9 @@ class PackFreeBSDElf32x86 : public PackBSDElf32x86
public:
PackFreeBSDElf32x86(InputFile *f);
virtual ~PackFreeBSDElf32x86();
virtual int getFormat() const { return UPX_F_BSD_ELF_i386; }
virtual const char *getName() const { return "freebsd/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-freebsd.elf"; }
virtual int getFormat() const override { return UPX_F_BSD_ELF_i386; }
virtual const char *getName() const override { return "freebsd/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-freebsd.elf"; }
};
class PackNetBSDElf32x86 : public PackLinuxElf32x86
@ -602,16 +602,16 @@ class PackNetBSDElf32x86 : public PackLinuxElf32x86
public:
PackNetBSDElf32x86(InputFile *f);
virtual ~PackNetBSDElf32x86();
virtual int getFormat() const { return UPX_F_BSD_ELF_i386; }
virtual const char *getName() const { return "netbsd/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-netbsd.elf"; }
virtual int getFormat() const override { return UPX_F_BSD_ELF_i386; }
virtual const char *getName() const override { return "netbsd/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-netbsd.elf"; }
protected:
virtual void buildLoader(const Filter *ft);
virtual void buildLoader(const Filter *ft) override;
virtual void generateElfHdr(
OutputFile *,
void const *proto,
unsigned const brka
);
) override;
};
class PackOpenBSDElf32x86 : public PackBSDElf32x86
@ -620,17 +620,17 @@ class PackOpenBSDElf32x86 : public PackBSDElf32x86
public:
PackOpenBSDElf32x86(InputFile *f);
virtual ~PackOpenBSDElf32x86();
virtual int getFormat() const { return UPX_F_BSD_ELF_i386; }
virtual const char *getName() const { return "openbsd/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-openbsd.elf"; }
virtual int getFormat() const override { return UPX_F_BSD_ELF_i386; }
virtual const char *getName() const override { return "openbsd/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-openbsd.elf"; }
protected:
virtual void buildLoader(const Filter *ft);
virtual void buildLoader(const Filter *ft) override;
virtual void generateElfHdr(
OutputFile *,
void const *proto,
unsigned const brka
);
) override;
};
@ -644,18 +644,18 @@ class PackLinuxElf32armLe : public PackLinuxElf32Le
public:
PackLinuxElf32armLe(InputFile *f);
virtual ~PackLinuxElf32armLe();
virtual int getFormat() const { return UPX_F_LINUX_ELF32_ARMEL; }
virtual const char *getName() const { return "linux/arm"; }
virtual const char *getFullName(const options_t *) const { return "arm-linux.elf"; }
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_LINUX_ELF32_ARMEL; }
virtual const char *getName() const override { return "linux/arm"; }
virtual const char *getFullName(const options_t *) const override { return "arm-linux.elf"; }
virtual const int *getFilters() const override;
protected:
virtual const int *getCompressionMethods(int method, int level) const;
virtual Linker* newLinker() const;
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void buildLoader(const Filter *);
virtual void updateLoader(OutputFile *);
virtual void defineSymbols(Filter const *);
virtual const int *getCompressionMethods(int method, int level) const override;
virtual Linker* newLinker() const override;
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *) override;
virtual void updateLoader(OutputFile *) override;
virtual void defineSymbols(Filter const *) override;
};
class PackLinuxElf32armBe : public PackLinuxElf32Be
@ -664,18 +664,18 @@ class PackLinuxElf32armBe : public PackLinuxElf32Be
public:
PackLinuxElf32armBe(InputFile *f);
virtual ~PackLinuxElf32armBe();
virtual int getFormat() const { return UPX_F_LINUX_ELF32_ARMEB; }
virtual const char *getName() const { return "linux/armeb"; }
virtual const char *getFullName(const options_t *) const { return "armeb-linux.elf"; }
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_LINUX_ELF32_ARMEB; }
virtual const char *getName() const override { return "linux/armeb"; }
virtual const char *getFullName(const options_t *) const override { return "armeb-linux.elf"; }
virtual const int *getFilters() const override;
protected:
virtual const int *getCompressionMethods(int method, int level) const;
virtual Linker* newLinker() const;
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void buildLoader(const Filter *);
virtual void updateLoader(OutputFile *);
virtual void defineSymbols(Filter const *);
virtual const int *getCompressionMethods(int method, int level) const override;
virtual Linker* newLinker() const override;
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *) override;
virtual void updateLoader(OutputFile *) override;
virtual void defineSymbols(Filter const *) override;
};
class PackLinuxElf32mipseb : public PackLinuxElf32Be
@ -684,17 +684,17 @@ class PackLinuxElf32mipseb : public PackLinuxElf32Be
public:
PackLinuxElf32mipseb(InputFile *f);
virtual ~PackLinuxElf32mipseb();
virtual int getFormat() const { return UPX_F_LINUX_ELF32_MIPSEB; }
virtual const char *getName() const { return "linux/mips"; }
virtual const char *getFullName(const options_t *) const { return "mips-linux.elf"; }
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_LINUX_ELF32_MIPSEB; }
virtual const char *getName() const override { return "linux/mips"; }
virtual const char *getFullName(const options_t *) const override { return "mips-linux.elf"; }
virtual const int *getFilters() const override;
protected:
virtual Linker* newLinker() const;
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void buildLoader(const Filter *);
virtual void updateLoader(OutputFile *);
virtual void defineSymbols(Filter const *);
virtual Linker* newLinker() const override;
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *) override;
virtual void updateLoader(OutputFile *) override;
virtual void defineSymbols(Filter const *) override;
};
class PackLinuxElf32mipsel : public PackLinuxElf32Le
@ -703,17 +703,17 @@ class PackLinuxElf32mipsel : public PackLinuxElf32Le
public:
PackLinuxElf32mipsel(InputFile *f);
virtual ~PackLinuxElf32mipsel();
virtual int getFormat() const { return UPX_F_LINUX_ELF32_MIPSEL; }
virtual const char *getName() const { return "linux/mipsel"; }
virtual const char *getFullName(const options_t *) const { return "mipsel-linux.elf"; }
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_LINUX_ELF32_MIPSEL; }
virtual const char *getName() const override { return "linux/mipsel"; }
virtual const char *getFullName(const options_t *) const override { return "mipsel-linux.elf"; }
virtual const int *getFilters() const override;
protected:
virtual Linker* newLinker() const;
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void buildLoader(const Filter *);
virtual void updateLoader(OutputFile *);
virtual void defineSymbols(Filter const *);
virtual Linker* newLinker() const override;
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *) override;
virtual void updateLoader(OutputFile *) override;
virtual void defineSymbols(Filter const *) override;
};

40
src/p_lx_exc.h
View File

@ -47,23 +47,23 @@ public:
void const *proto,
unsigned const brka
);
virtual int getFormat() const { return UPX_F_LINUX_i386; }
virtual const char *getName() const { return "linux.exec/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-linux.elf.execve"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual void buildLoader(const Filter *);
virtual int getFormat() const override { return UPX_F_LINUX_i386; }
virtual const char *getName() const override { return "linux.exec/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-linux.elf.execve"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
virtual void buildLoader(const Filter *) override;
virtual bool canPack();
virtual bool canPack() override;
protected:
virtual void pack1(OutputFile *, Filter &); // generate executable header
// virtual void pack2(OutputFile *, Filter &); // append compressed data
// virtual void pack3(OutputFile *, Filter &); // append loader
virtual void pack4(OutputFile *, Filter &); // append PackHeader
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
// virtual void pack2(OutputFile *, Filter &) override; // append compressed data
// virtual void pack3(OutputFile *, Filter &) override; // append loader
virtual void pack4(OutputFile *, Filter &) override; // append PackHeader
// loader util
virtual Linker* newLinker() const;
virtual Linker* newLinker() const override;
virtual int getLoaderPrefixSize() const;
virtual void buildLinuxLoader(
upx_byte const *const proto, // assembly-only sections
@ -74,9 +74,9 @@ protected:
);
// patch util
virtual void patchLoader();
virtual void patchLoaderChecksum();
virtual void updateLoader(OutputFile *);
virtual void patchLoader() override;
virtual void patchLoaderChecksum() override;
virtual void updateLoader(OutputFile *) override;
// ELF util
virtual int checkEhdr(const Elf_LE32_Ehdr *ehdr) const;
@ -134,14 +134,14 @@ class PackBSDI386 : public PackLinuxI386
typedef PackLinuxI386 super;
public:
PackBSDI386(InputFile *f);
virtual int getFormat() const { return UPX_F_BSD_i386; }
virtual const char *getName() const { return "bsd.exec/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-bsd.elf.execve"; }
virtual int getFormat() const override { return UPX_F_BSD_i386; }
virtual const char *getName() const override { return "bsd.exec/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-bsd.elf.execve"; }
protected:
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual void buildLoader(const Filter *);
virtual void buildLoader(const Filter *) override;
};
#endif /* already included */

18
src/p_lx_interp.h
View File

@ -44,18 +44,18 @@ class PackLinuxElf32x86interp : public PackLinuxElf32x86
public:
PackLinuxElf32x86interp(InputFile *f);
virtual ~PackLinuxElf32x86interp();
virtual int getVersion() const { return 13; }
virtual int getFormat() const { return UPX_F_LINUX_ELFI_i386; }
virtual const char *getName() const { return "linux/elfi386"; }
virtual const char *getFullName(const options_t *) const { return "i386-linux.elf.interp"; }
virtual int getVersion() const override { return 13; }
virtual int getFormat() const override { return UPX_F_LINUX_ELFI_i386; }
virtual const char *getName() const override { return "linux/elfi386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-linux.elf.interp"; }
virtual bool canPack();
virtual void unpack(OutputFile *fo);
virtual bool canPack() override;
virtual void unpack(OutputFile *fo) override;
protected:
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual int pack2(OutputFile *, Filter &); // append compressed data
virtual off_t pack3(OutputFile *, Filter &); // build loader
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual int pack2(OutputFile *, Filter &) override; // append compressed data
virtual off_t pack3(OutputFile *, Filter &) override; // build loader
};

22
src/p_lx_sh.h
View File

@ -44,25 +44,25 @@ class PackLinuxI386sh : public PackLinuxI386
public:
PackLinuxI386sh(InputFile *f);
virtual ~PackLinuxI386sh();
virtual int getVersion() const { return 13; }
virtual int getFormat() const { return UPX_F_LINUX_SH_i386; }
virtual const char *getName() const { return "linux.sh/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-linux.elf.shell"; }
virtual const int *getFilters() const { return nullptr; }
virtual void buildLoader(const Filter *);
virtual int getVersion() const override { return 13; }
virtual int getFormat() const override { return UPX_F_LINUX_SH_i386; }
virtual const char *getName() const override { return "linux.sh/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-linux.elf.shell"; }
virtual const int *getFilters() const override { return nullptr; }
virtual void buildLoader(const Filter *) override;
virtual void pack1(OutputFile *fo, Filter &ft);
virtual off_t pack3(OutputFile *fo, Filter &ft);
virtual void pack1(OutputFile *fo, Filter &ft) override;
virtual off_t pack3(OutputFile *fo, Filter &ft) override;
virtual bool canPack();
virtual bool canPack() override;
// virtual void unpack(OutputFile *fo) { super::unpack(fo); }
virtual bool canUnpackVersion(int version) const
virtual bool canUnpackVersion(int version) const override
{ return (version >= 11); }
protected:
virtual bool getShellName(char *buf);
virtual void patchLoader();
virtual void patchLoader() override;
int o_shname; // offset to name_of_shell
int l_shname; // length of name_of_shell

236
src/p_mach.h
View File

@ -742,14 +742,14 @@ public:
unsigned t_flavor, unsigned ts_word_cnt, unsigned tc_size,
unsigned page_shift);
virtual ~PackMachBase();
virtual int getVersion() const { return 13; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual int getVersion() const override { return 13; }
virtual const int *getCompressionMethods(int method, int level) const override;
// called by the generic pack()
virtual void pack1(OutputFile *, Filter &); // generate executable header
virtual int pack2(OutputFile *, Filter &); // append compressed data
virtual off_t pack3(OutputFile *, Filter &) /*= 0*/; // append loader
virtual void pack4(OutputFile *, Filter &) /*= 0*/; // append PackHeader
virtual void pack1(OutputFile *, Filter &) override; // generate executable header
virtual int pack2(OutputFile *, Filter &) override; // append compressed data
virtual off_t pack3(OutputFile *, Filter &) override /*= 0*/; // append loader
virtual void pack4(OutputFile *, Filter &) override /*= 0*/; // append PackHeader
virtual void pack4dylib(OutputFile *, Filter &, Addr init_address);
@ -758,18 +758,18 @@ public:
virtual void threado_rewrite(OutputFile *) = 0;
virtual void threado_write(OutputFile *) = 0;
virtual void pack1_setup_threado(OutputFile *const fo) = 0;
virtual void unpack(OutputFile *fo);
virtual void unpack(OutputFile *fo) override;
virtual bool canPack();
virtual int canUnpack();
virtual bool canPack() override;
virtual int canUnpack() override;
virtual upx_uint64_t get_mod_init_func(Mach_segment_command const *segptr);
virtual unsigned find_SEGMENT_gap(unsigned const k, unsigned pos_eof);
protected:
virtual void patchLoader();
virtual void patchLoaderChecksum();
virtual void updateLoader(OutputFile *);
virtual void buildLoader(const Filter *ft);
virtual void patchLoader() override;
virtual void patchLoaderChecksum() override;
virtual void updateLoader(OutputFile *) override;
virtual void buildLoader(const Filter *ft) override;
virtual void buildMachLoader(
upx_byte const *const proto,
unsigned const szproto,
@ -871,16 +871,16 @@ class PackMachPPC32 : public PackMachBase<MachClass_BE32>
public:
PackMachPPC32(InputFile *f);
virtual int getFormat() const { return UPX_F_MACH_PPC32; }
virtual const char *getName() const { return "macho/ppc32"; }
virtual const char *getFullName(const options_t *) const { return "powerpc-darwin.macho"; }
virtual int getFormat() const override { return UPX_F_MACH_PPC32; }
virtual const char *getName() const override { return "macho/ppc32"; }
virtual const char *getFullName(const options_t *) const override { return "powerpc-darwin.macho"; }
protected:
virtual const int *getFilters() const;
virtual const int *getFilters() const override;
virtual void pack1_setup_threado(OutputFile *const fo);
virtual Linker* newLinker() const;
virtual void addStubEntrySections(Filter const *);
virtual void pack1_setup_threado(OutputFile *const fo) override;
virtual Linker* newLinker() const override;
virtual void addStubEntrySections(Filter const *) override;
__packed_struct(Mach_thread_command)
TE32 cmd; /* LC_THREAD or LC_UNIXTHREAD */
@ -893,8 +893,8 @@ protected:
__packed_struct_end()
Mach_thread_command threado;
int threado_size() const { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) {
int threado_size() const override { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) override {
memset(&threado, 0, sizeof(threado));
threado.cmd = Mach_segment_command::LC_UNIXTHREAD;
threado.cmdsize = sizeof(threado);
@ -902,10 +902,10 @@ protected:
threado.count = my_thread_state_word_count;
threado.state.srr0 = pc;
}
void threado_rewrite(OutputFile *fo) { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) { fo->write(&threado, sizeof(threado)); }
void threado_rewrite(OutputFile *fo) override { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) override { fo->write(&threado, sizeof(threado)); }
upx_uint64_t threadc_getPC(void const *ptr) {
upx_uint64_t threadc_getPC(void const *ptr) override {
Mach_thread_command const *tc = (Mach_thread_command const *)ptr;
if (tc->cmd!=Mach_segment_command::LC_UNIXTHREAD
|| tc->cmdsize!=sizeof(threado)
@ -924,15 +924,15 @@ class PackMachPPC64 : public PackMachBase<MachClass_BE64>
public:
PackMachPPC64(InputFile *f);
virtual int getFormat() const { return UPX_F_MACH_PPC64; }
virtual const char *getName() const { return "macho/ppc64"; }
virtual const char *getFullName(const options_t *) const { return "powerpc64-darwin.macho"; }
virtual int getFormat() const override { return UPX_F_MACH_PPC64; }
virtual const char *getName() const override { return "macho/ppc64"; }
virtual const char *getFullName(const options_t *) const override { return "powerpc64-darwin.macho"; }
protected:
virtual const int *getFilters() const;
virtual const int *getFilters() const override;
virtual void pack1_setup_threado(OutputFile *const fo);
virtual Linker* newLinker() const;
virtual void pack1_setup_threado(OutputFile *const fo) override;
virtual Linker* newLinker() const override;
__packed_struct(Mach_thread_command)
BE32 cmd; /* LC_THREAD or LC_UNIXTHREAD */
@ -945,8 +945,8 @@ protected:
__packed_struct_end()
Mach_thread_command threado;
int threado_size() const { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) {
int threado_size() const override { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) override {
memset(&threado, 0, sizeof(threado));
threado.cmd = Mach_segment_command::LC_UNIXTHREAD;
threado.cmdsize = sizeof(threado);
@ -954,10 +954,10 @@ protected:
threado.count = my_thread_state_word_count;
threado.state64.srr0 = pc;
}
void threado_rewrite(OutputFile *fo) { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) { fo->write(&threado, sizeof(threado)); }
void threado_rewrite(OutputFile *fo) override { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) override { fo->write(&threado, sizeof(threado)); }
upx_uint64_t threadc_getPC(void const *ptr) {
upx_uint64_t threadc_getPC(void const *ptr) override{
Mach_thread_command const *tc = (Mach_thread_command const *)ptr;
if (tc->cmd!=Mach_segment_command::LC_UNIXTHREAD
|| tc->cmdsize!=sizeof(threado)
@ -976,12 +976,12 @@ class PackDylibPPC32 : public PackMachPPC32
public:
PackDylibPPC32(InputFile *f);
virtual int getFormat() const { return UPX_F_DYLIB_PPC32; }
virtual const char *getName() const { return "dylib/ppc32"; }
virtual const char *getFullName(const options_t *) const { return "powerpc-darwin.dylib"; }
virtual int getFormat() const override { return UPX_F_DYLIB_PPC32; }
virtual const char *getName() const override { return "dylib/ppc32"; }
virtual const char *getFullName(const options_t *) const override { return "powerpc-darwin.dylib"; }
protected:
virtual off_t pack3(OutputFile *, Filter &); // append loader
virtual void pack4(OutputFile *, Filter &); // append PackHeader
virtual off_t pack3(OutputFile *, Filter &) override; // append loader
virtual void pack4(OutputFile *, Filter &) override; // append PackHeader
};
class PackDylibPPC64 : public PackMachPPC64
@ -991,12 +991,12 @@ class PackDylibPPC64 : public PackMachPPC64
public:
PackDylibPPC64(InputFile *f);
virtual int getFormat() const { return UPX_F_DYLIB_PPC64; }
virtual const char *getName() const { return "dylib/ppc64"; }
virtual const char *getFullName(const options_t *) const { return "powerpc64-darwin.dylib"; }
virtual int getFormat() const override { return UPX_F_DYLIB_PPC64; }
virtual const char *getName() const override { return "dylib/ppc64"; }
virtual const char *getFullName(const options_t *) const override { return "powerpc64-darwin.dylib"; }
protected:
virtual off_t pack3(OutputFile *, Filter &); // append loader
virtual void pack4(OutputFile *, Filter &); // append PackHeader
virtual off_t pack3(OutputFile *, Filter &) override; // append loader
virtual void pack4(OutputFile *, Filter &) override; // append PackHeader
};
class PackMachI386 : public PackMachBase<MachClass_LE32>
@ -1006,15 +1006,15 @@ class PackMachI386 : public PackMachBase<MachClass_LE32>
public:
PackMachI386(InputFile *f);
virtual int getFormat() const { return UPX_F_MACH_i386; }
virtual const char *getName() const { return "macho/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-darwin.macho"; }
virtual int getFormat() const override { return UPX_F_MACH_i386; }
virtual const char *getName() const override { return "macho/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-darwin.macho"; }
protected:
virtual const int *getFilters() const;
virtual const int *getFilters() const override;
virtual void pack1_setup_threado(OutputFile *const fo);
virtual Linker* newLinker() const;
virtual void addStubEntrySections(Filter const *);
virtual void pack1_setup_threado(OutputFile *const fo) override;
virtual Linker* newLinker() const override;
virtual void addStubEntrySections(Filter const *) override;
__packed_struct(Mach_thread_command)
LE32 cmd; /* LC_THREAD or LC_UNIXTHREAD */
@ -1027,8 +1027,8 @@ protected:
__packed_struct_end()
Mach_thread_command threado;
int threado_size() const { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) {
int threado_size() const override { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) override {
memset(&threado, 0, sizeof(threado));
threado.cmd = Mach_segment_command::LC_UNIXTHREAD;
threado.cmdsize = sizeof(threado);
@ -1036,10 +1036,10 @@ protected:
threado.count = my_thread_state_word_count;
threado.state.eip = pc;
}
void threado_rewrite(OutputFile *fo) { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) { fo->write(&threado, sizeof(threado)); }
void threado_rewrite(OutputFile *fo) override { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) override { fo->write(&threado, sizeof(threado)); }
upx_uint64_t threadc_getPC(void const *ptr) {
upx_uint64_t threadc_getPC(void const *ptr) override{
Mach_thread_command const *tc = (Mach_thread_command const *)ptr;
if (tc->cmd!=Mach_segment_command::LC_UNIXTHREAD
|| tc->cmdsize!=sizeof(threado)
@ -1058,12 +1058,12 @@ class PackDylibI386 : public PackMachI386
public:
PackDylibI386(InputFile *f);
virtual int getFormat() const { return UPX_F_DYLIB_i386; }
virtual const char *getName() const { return "dylib/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-darwin.dylib"; }
virtual int getFormat() const override { return UPX_F_DYLIB_i386; }
virtual const char *getName() const override { return "dylib/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-darwin.dylib"; }
protected:
virtual off_t pack3(OutputFile *, Filter &); // append loader
virtual void pack4(OutputFile *, Filter &); // append PackHeader
virtual off_t pack3(OutputFile *, Filter &) override; // append loader
virtual void pack4(OutputFile *, Filter &) override; // append PackHeader
};
class PackMachAMD64 : public PackMachBase<MachClass_LE64>
@ -1073,15 +1073,15 @@ class PackMachAMD64 : public PackMachBase<MachClass_LE64>
public:
PackMachAMD64(InputFile *f);
virtual int getFormat() const { return UPX_F_MACH_AMD64; }
virtual const char *getName() const { return "macho/amd64"; }
virtual const char *getFullName(const options_t *) const { return "amd64-darwin.macho"; }
virtual int getFormat() const override { return UPX_F_MACH_AMD64; }
virtual const char *getName() const override { return "macho/amd64"; }
virtual const char *getFullName(const options_t *) const override { return "amd64-darwin.macho"; }
protected:
virtual const int *getFilters() const;
virtual const int *getFilters() const override;
virtual void pack1_setup_threado(OutputFile *const fo);
virtual Linker* newLinker() const;
virtual void addStubEntrySections(Filter const *);
virtual void pack1_setup_threado(OutputFile *const fo) override;
virtual Linker* newLinker() const override;
virtual void addStubEntrySections(Filter const *) override;
__packed_struct(Mach_thread_command)
typedef MachITypes::Word Word;
@ -1095,8 +1095,8 @@ protected:
__packed_struct_end()
Mach_thread_command threado;
int threado_size() const { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) {
int threado_size() const override { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) override {
memset(&threado, 0, sizeof(threado));
threado.cmd = Mach_segment_command::LC_UNIXTHREAD;
threado.cmdsize = sizeof(threado);
@ -1104,10 +1104,10 @@ protected:
threado.count = my_thread_state_word_count;
threado.state.rip = pc;
}
void threado_rewrite(OutputFile *fo) { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) { fo->write(&threado, sizeof(threado)); }
void threado_rewrite(OutputFile *fo) override { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) override { fo->write(&threado, sizeof(threado)); }
upx_uint64_t threadc_getPC(void const *ptr) {
upx_uint64_t threadc_getPC(void const *ptr) override {
Mach_thread_command const *tc = (Mach_thread_command const *)ptr;
if (tc->cmd!=Mach_segment_command::LC_UNIXTHREAD
|| tc->cmdsize!=sizeof(threado)
@ -1126,12 +1126,12 @@ class PackDylibAMD64 : public PackMachAMD64
public:
PackDylibAMD64(InputFile *f);
virtual int getFormat() const { return UPX_F_DYLIB_AMD64; }
virtual const char *getName() const { return "dylib/amd64"; }
virtual const char *getFullName(const options_t *) const { return "amd64-darwin.dylib"; }
virtual int getFormat() const override { return UPX_F_DYLIB_AMD64; }
virtual const char *getName() const override { return "dylib/amd64"; }
virtual const char *getFullName(const options_t *) const override { return "amd64-darwin.dylib"; }
protected:
virtual off_t pack3(OutputFile *, Filter &); // append loader
virtual void pack4(OutputFile *, Filter &); // append PackHeader
virtual off_t pack3(OutputFile *, Filter &) override; // append loader
virtual void pack4(OutputFile *, Filter &) override; // append PackHeader
};
class PackMachARMEL : public PackMachBase<MachClass_LE32>
@ -1141,16 +1141,16 @@ class PackMachARMEL : public PackMachBase<MachClass_LE32>
public:
PackMachARMEL(InputFile *f);
virtual int getFormat() const { return UPX_F_MACH_ARMEL; }
virtual const char *getName() const { return "macho/arm"; }
virtual const char *getFullName(const options_t *) const { return "arm-darwin.macho"; }
virtual int getFormat() const override { return UPX_F_MACH_ARMEL; }
virtual const char *getName() const override { return "macho/arm"; }
virtual const char *getFullName(const options_t *) const override { return "arm-darwin.macho"; }
protected:
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
virtual void pack1_setup_threado(OutputFile *const fo);
virtual Linker* newLinker() const;
virtual void addStubEntrySections(Filter const *);
virtual void pack1_setup_threado(OutputFile *const fo) override;
virtual Linker* newLinker() const override;
virtual void addStubEntrySections(Filter const *) override;
__packed_struct(Mach_thread_command)
LE32 cmd; /* LC_THREAD or LC_UNIXTHREAD */
@ -1163,8 +1163,8 @@ protected:
__packed_struct_end()
Mach_thread_command threado;
int threado_size() const { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) {
int threado_size() const override { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) override {
memset(&threado, 0, sizeof(threado));
threado.cmd = Mach_segment_command::LC_UNIXTHREAD;
threado.cmdsize = sizeof(threado);
@ -1172,10 +1172,10 @@ protected:
threado.count = my_thread_state_word_count;
threado.state.pc = pc;
}
void threado_rewrite(OutputFile *fo) { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) { return fo->write(&threado, sizeof(threado)); }
void threado_rewrite(OutputFile *fo) override { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) override { return fo->write(&threado, sizeof(threado)); }
upx_uint64_t threadc_getPC(void const *ptr) {
upx_uint64_t threadc_getPC(void const *ptr) override {
Mach_thread_command const *tc = (Mach_thread_command const *)ptr;
if (tc->cmd!=Mach_segment_command::LC_UNIXTHREAD
|| tc->cmdsize!=sizeof(threado)
@ -1194,15 +1194,15 @@ class PackMachARM64EL : public PackMachBase<MachClass_LE64>
public:
PackMachARM64EL(InputFile *f);
virtual int getFormat() const { return UPX_F_MACH_ARM64EL; }
virtual const char *getName() const { return "macho/arm64"; }
virtual const char *getFullName(const options_t *) const { return "arm64-darwin.macho"; }
virtual int getFormat() const override { return UPX_F_MACH_ARM64EL; }
virtual const char *getName() const override { return "macho/arm64"; }
virtual const char *getFullName(const options_t *) const override { return "arm64-darwin.macho"; }
protected:
virtual const int *getFilters() const;
virtual const int *getFilters() const override;
virtual void pack1_setup_threado(OutputFile *const fo);
virtual Linker* newLinker() const;
virtual void addStubEntrySections(Filter const *);
virtual void pack1_setup_threado(OutputFile *const fo) override;
virtual Linker* newLinker() const override;
virtual void addStubEntrySections(Filter const *) override;
__packed_struct(Mach_thread_command)
LE32 cmd; /* LC_THREAD or LC_UNIXTHREAD */
@ -1215,8 +1215,8 @@ protected:
__packed_struct_end()
Mach_thread_command threado;
int threado_size() const { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) {
int threado_size() const override { return sizeof(threado); }
void threado_setPC(upx_uint64_t pc) override {
memset(&threado, 0, sizeof(threado));
threado.cmd = Mach_segment_command::LC_UNIXTHREAD;
threado.cmdsize = sizeof(threado);
@ -1224,10 +1224,10 @@ protected:
threado.count = my_thread_state_word_count;
threado.state.pc = pc;
}
void threado_rewrite(OutputFile *fo) { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) { fo->write(&threado, sizeof(threado)); }
void threado_rewrite(OutputFile *fo) override { fo->rewrite(&threado, sizeof(threado)); }
void threado_write(OutputFile *fo) override { fo->write(&threado, sizeof(threado)); }
upx_uint64_t threadc_getPC(void const *ptr) {
upx_uint64_t threadc_getPC(void const *ptr) override {
Mach_thread_command const *tc = (Mach_thread_command const *)ptr;
if (tc->cmd!=Mach_segment_command::LC_UNIXTHREAD
|| tc->cmdsize!=sizeof(threado)
@ -1246,28 +1246,28 @@ public:
PackMachFat(InputFile *f);
virtual ~PackMachFat();
virtual int getVersion() const { return 13; }
virtual int getFormat() const { return UPX_F_MACH_FAT; }
virtual const char *getName() const { return "macho/fat"; }
virtual const char *getFullName(const options_t *) const { return "fat-darwin.macho"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual int getVersion() const override { return 13; }
virtual int getFormat() const override { return UPX_F_MACH_FAT; }
virtual const char *getName() const override { return "macho/fat"; }
virtual const char *getFullName(const options_t *) const override { return "fat-darwin.macho"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
protected:
// implementation
virtual unsigned check_fat_head(); // number of architectures
virtual void pack(OutputFile *fo);
virtual void unpack(OutputFile *fo);
virtual void list();
virtual void pack(OutputFile *fo) override;
virtual void unpack(OutputFile *fo) override;
virtual void list() override;
public:
virtual bool canPack();
virtual int canUnpack();
virtual bool canPack() override;
virtual int canUnpack() override;
protected:
// loader core
virtual void buildLoader(const Filter *ft);
virtual Linker* newLinker() const;
virtual void buildLoader(const Filter *ft) override;
virtual Linker* newLinker() const override;
enum { N_FAT_ARCH = 5 };
protected:

14
src/p_unix.h
View File

@ -41,15 +41,15 @@ class PackUnix : public Packer
protected:
PackUnix(InputFile *f);
public:
virtual int getVersion() const { return 13; }
virtual const int *getFilters() const { return nullptr; }
virtual int getVersion() const override { return 13; }
virtual const int *getFilters() const override { return nullptr; }
virtual int getStrategy(Filter &);
virtual void pack(OutputFile *fo);
virtual void unpack(OutputFile *fo);
virtual void pack(OutputFile *fo) override;
virtual void unpack(OutputFile *fo) override;
virtual bool canPack();
virtual int canUnpack();
virtual bool canPack() override;
virtual int canUnpack() override;
int find_overlay_offset(MemBuffer const &buf);
protected:
@ -65,7 +65,7 @@ protected:
virtual void writePackHeader(OutputFile *fo);
virtual bool checkCompressionRatio(unsigned, unsigned) const;
virtual bool checkCompressionRatio(unsigned, unsigned) const override;
protected:
struct Extent {

142
src/p_vmlinx.h
View File

@ -59,7 +59,7 @@ protected:
public:
PackVmlinuxBase(InputFile *, unsigned, unsigned, unsigned, char const *);
virtual ~PackVmlinuxBase();
virtual int getVersion() const { return 13; }
virtual int getVersion() const override { return 13; }
protected:
unsigned int const my_e_machine;
@ -82,10 +82,10 @@ protected:
virtual int getStrategy(Filter &/*ft*/);
virtual bool is_valid_e_entry(Addr) = 0;
virtual bool has_valid_vmlinux_head() = 0;
virtual bool canPack();
virtual void pack(OutputFile *fo);
virtual int canUnpack(); // bool, except -1: format known, but not packed
virtual void unpack(OutputFile *fo);
virtual bool canPack() override;
virtual void pack(OutputFile *fo) override;
virtual int canUnpack() override; // bool, except -1: format known, but not packed
virtual void unpack(OutputFile *fo) override;
virtual unsigned write_vmlinux_head(
OutputFile *fo,
Shdr *stxt
@ -100,22 +100,22 @@ class PackVmlinuxI386 : public PackVmlinuxBase<ElfClass_LE32>
public:
PackVmlinuxI386(InputFile *f) : super(f, Ehdr::EM_386,
Ehdr::ELFCLASS32, Ehdr::ELFDATA2LSB, "startup_32") { }
virtual int getFormat() const { return UPX_F_VMLINUX_i386; }
virtual const char *getName() const { return "vmlinux/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_VMLINUX_i386; }
virtual const char *getName() const override { return "vmlinux/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
protected:
virtual void buildLoader(const Filter *ft);
virtual void defineDecompressorSymbols();
virtual Linker* newLinker() const;
virtual bool is_valid_e_entry(Addr);
virtual bool has_valid_vmlinux_head();
virtual void buildLoader(const Filter *ft) override;
virtual void defineDecompressorSymbols() override;
virtual Linker* newLinker() const override;
virtual bool is_valid_e_entry(Addr) override;
virtual bool has_valid_vmlinux_head() override;
virtual unsigned write_vmlinux_head(
OutputFile *fo,
Shdr *stxt
);
) override;
};
@ -125,22 +125,22 @@ class PackVmlinuxARMEL : public PackVmlinuxBase<ElfClass_LE32>
public:
PackVmlinuxARMEL(InputFile *f) : super(f, Ehdr::EM_ARM,
Ehdr::ELFCLASS32, Ehdr::ELFDATA2LSB, "decompress_kernel") { }
virtual int getFormat() const { return UPX_F_VMLINUX_ARMEL; }
virtual const char *getName() const { return "vmlinux/arm"; }
virtual const char *getFullName(const options_t *) const { return "arm-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_VMLINUX_ARMEL; }
virtual const char *getName() const override { return "vmlinux/arm"; }
virtual const char *getFullName(const options_t *) const override { return "arm-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
protected:
virtual void buildLoader(const Filter *ft);
virtual void defineDecompressorSymbols();
virtual Linker* newLinker() const;
virtual bool is_valid_e_entry(Addr);
virtual bool has_valid_vmlinux_head();
virtual void buildLoader(const Filter *ft) override;
virtual void defineDecompressorSymbols() override;
virtual Linker* newLinker() const override;
virtual bool is_valid_e_entry(Addr) override;
virtual bool has_valid_vmlinux_head() override;
virtual unsigned write_vmlinux_head(
OutputFile *fo,
Shdr *stxt
);
) override;
};
class PackVmlinuxARMEB : public PackVmlinuxBase<ElfClass_BE32>
@ -149,22 +149,22 @@ class PackVmlinuxARMEB : public PackVmlinuxBase<ElfClass_BE32>
public:
PackVmlinuxARMEB(InputFile *f) : super(f, Ehdr::EM_ARM,
Ehdr::ELFCLASS32, Ehdr::ELFDATA2MSB, "decompress_kernel") { }
virtual int getFormat() const { return UPX_F_VMLINUX_ARMEB; }
virtual const char *getName() const { return "vmlinux/armeb"; }
virtual const char *getFullName(const options_t *) const { return "armeb-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_VMLINUX_ARMEB; }
virtual const char *getName() const override { return "vmlinux/armeb"; }
virtual const char *getFullName(const options_t *) const override { return "armeb-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
protected:
virtual void buildLoader(const Filter *ft);
virtual void defineDecompressorSymbols();
virtual Linker* newLinker() const;
virtual bool is_valid_e_entry(Addr);
virtual bool has_valid_vmlinux_head();
virtual void buildLoader(const Filter *ft) override;
virtual void defineDecompressorSymbols() override;
virtual Linker* newLinker() const override;
virtual bool is_valid_e_entry(Addr) override;
virtual bool has_valid_vmlinux_head() override;
virtual unsigned write_vmlinux_head(
OutputFile *fo,
Shdr *stxt
);
) override;
};
class PackVmlinuxPPC32 : public PackVmlinuxBase<ElfClass_BE32>
@ -173,22 +173,22 @@ class PackVmlinuxPPC32 : public PackVmlinuxBase<ElfClass_BE32>
public:
PackVmlinuxPPC32(InputFile *f) : super(f, Ehdr::EM_PPC,
Ehdr::ELFCLASS32, Ehdr::ELFDATA2MSB, "_vmlinux_start") { }
virtual int getFormat() const { return UPX_F_VMLINUX_PPC32; }
virtual const char *getName() const { return "vmlinux/ppc32"; }
virtual const char *getFullName(const options_t *) const { return "powerpc-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_VMLINUX_PPC32; }
virtual const char *getName() const override { return "vmlinux/ppc32"; }
virtual const char *getFullName(const options_t *) const override { return "powerpc-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
protected:
virtual void buildLoader(const Filter *ft);
virtual void defineDecompressorSymbols();
virtual Linker* newLinker() const;
virtual bool is_valid_e_entry(Addr);
virtual bool has_valid_vmlinux_head();
virtual void buildLoader(const Filter *ft) override;
virtual void defineDecompressorSymbols() override;
virtual Linker* newLinker() const override;
virtual bool is_valid_e_entry(Addr) override;
virtual bool has_valid_vmlinux_head() override;
virtual unsigned write_vmlinux_head(
OutputFile *fo,
Shdr *stxt
);
) override;
};
class PackVmlinuxPPC64LE : public PackVmlinuxBase<ElfClass_LE64>
@ -197,22 +197,22 @@ class PackVmlinuxPPC64LE : public PackVmlinuxBase<ElfClass_LE64>
public:
PackVmlinuxPPC64LE(InputFile *f) : super(f, Ehdr::EM_PPC64,
Ehdr::ELFCLASS64, Ehdr::ELFDATA2LSB, "_vmlinux_start") { }
virtual int getFormat() const { return UPX_F_VMLINUX_PPC64LE; }
virtual const char *getName() const { return "vmlinux/ppc64le"; }
virtual const char *getFullName(const options_t *) const { return "powerpc64le-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_VMLINUX_PPC64LE; }
virtual const char *getName() const override { return "vmlinux/ppc64le"; }
virtual const char *getFullName(const options_t *) const override { return "powerpc64le-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
protected:
virtual void buildLoader(const Filter *ft);
virtual void defineDecompressorSymbols();
virtual Linker* newLinker() const;
virtual bool is_valid_e_entry(Addr);
virtual bool has_valid_vmlinux_head();
virtual void buildLoader(const Filter *ft) override;
virtual void defineDecompressorSymbols() override;
virtual Linker* newLinker() const override;
virtual bool is_valid_e_entry(Addr) override;
virtual bool has_valid_vmlinux_head() override;
virtual unsigned write_vmlinux_head(
OutputFile *fo,
Shdr *stxt
);
) override;
};
@ -222,22 +222,22 @@ class PackVmlinuxAMD64 : public PackVmlinuxBase<ElfClass_LE64>
public:
PackVmlinuxAMD64(InputFile *f) : super(f, Ehdr::EM_X86_64,
Ehdr::ELFCLASS64, Ehdr::ELFDATA2LSB, "startup_32") { }
virtual int getFormat() const { return UPX_F_VMLINUX_AMD64; }
virtual const char *getName() const { return "vmlinux/amd64"; }
virtual const char *getFullName(const options_t *) const { return "amd64-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_VMLINUX_AMD64; }
virtual const char *getName() const override { return "vmlinux/amd64"; }
virtual const char *getFullName(const options_t *) const override { return "amd64-linux.kernel.vmlinux"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
protected:
virtual void buildLoader(const Filter *ft);
virtual void defineDecompressorSymbols();
virtual Linker* newLinker() const;
virtual bool is_valid_e_entry(Addr);
virtual bool has_valid_vmlinux_head();
virtual void buildLoader(const Filter *ft) override;
virtual void defineDecompressorSymbols() override;
virtual Linker* newLinker() const override;
virtual bool is_valid_e_entry(Addr) override;
virtual bool has_valid_vmlinux_head() override;
virtual unsigned write_vmlinux_head(
OutputFile *fo,
Shdr *stxt
);
) override;
};

66
src/p_vmlinz.h
View File

@ -39,27 +39,27 @@ class PackVmlinuzI386 : public Packer
typedef Packer super;
public:
PackVmlinuzI386(InputFile *f);
virtual int getVersion() const { return 13; }
virtual int getFormat() const { return UPX_F_VMLINUZ_i386; }
virtual const char *getName() const { return "vmlinuz/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-linux.kernel.vmlinuz"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual int getVersion() const override { return 13; }
virtual int getFormat() const override { return UPX_F_VMLINUZ_i386; }
virtual const char *getName() const override { return "vmlinuz/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-linux.kernel.vmlinuz"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
virtual int getStrategy(Filter &);
virtual void pack(OutputFile *fo);
virtual void unpack(OutputFile *fo);
virtual void pack(OutputFile *fo) override;
virtual void unpack(OutputFile *fo) override;
virtual bool canPack();
virtual int canUnpack();
virtual bool canPack() override;
virtual int canUnpack() override;
protected:
virtual int readFileHeader();
virtual int decompressKernel();
virtual void readKernel();
virtual void buildLoader(const Filter *ft);
virtual Linker* newLinker() const;
virtual void buildLoader(const Filter *ft) override;
virtual Linker* newLinker() const override;
// virtual upx_byte *getLoader() const;
// virtual int getLoaderSize() const;
@ -109,15 +109,15 @@ class PackBvmlinuzI386 : public PackVmlinuzI386
typedef PackVmlinuzI386 super;
public:
PackBvmlinuzI386(InputFile *f) : super(f) { }
virtual int getFormat() const { return UPX_F_BVMLINUZ_i386; }
virtual const char *getName() const { return "bvmlinuz/i386"; }
virtual const char *getFullName(const options_t *) const { return "i386-linux.kernel.bvmlinuz"; }
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_BVMLINUZ_i386; }
virtual const char *getName() const override { return "bvmlinuz/i386"; }
virtual const char *getFullName(const options_t *) const override { return "i386-linux.kernel.bvmlinuz"; }
virtual const int *getFilters() const override;
virtual void pack(OutputFile *fo);
virtual void pack(OutputFile *fo) override;
protected:
virtual void buildLoader(const Filter *ft);
virtual void buildLoader(const Filter *ft) override;
};
@ -130,32 +130,32 @@ class PackVmlinuzARMEL : public Packer
typedef Packer super;
public:
PackVmlinuzARMEL(InputFile *f);
virtual int getVersion() const { return 13; }
virtual int getFormat() const { return UPX_F_VMLINUZ_ARMEL; }
virtual const char *getName() const { return "vmlinuz/arm"; }
virtual const char *getFullName(const options_t *) const { return "arm-linux.kernel.vmlinuz"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual int getVersion() const override { return 13; }
virtual int getFormat() const override{ return UPX_F_VMLINUZ_ARMEL; }
virtual const char *getName() const override { return "vmlinuz/arm"; }
virtual const char *getFullName(const options_t *) const override { return "arm-linux.kernel.vmlinuz"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
virtual int getStrategy(Filter &);
virtual void pack(OutputFile *fo);
virtual void unpack(OutputFile *fo);
virtual void pack(OutputFile *fo) override;
virtual void unpack(OutputFile *fo) override;
virtual bool canPack();
virtual int canUnpack();
virtual bool canPack() override;
virtual int canUnpack() override;
protected:
virtual int readFileHeader();
virtual int decompressKernel();
virtual void readKernel();
virtual void buildLoader(const Filter *ft);
virtual void buildLoader(const Filter *ft) override;
virtual unsigned write_vmlinuz_head(OutputFile *fo);
virtual void defineDecompressorSymbols();
virtual Linker* newLinker() const;
virtual void defineDecompressorSymbols() override;
virtual Linker* newLinker() const override;
// virtual upx_byte *getLoader() const;
// virtual int getLoaderSize() const;
// virtual upx_byte *getLoader() const override;
// virtual int getLoaderSize() const override;
MemBuffer setup_buf;

30
src/p_w32pe.h
View File

@ -41,28 +41,28 @@ class PackW32Pe : public PeFile32
public:
PackW32Pe(InputFile *f);
virtual ~PackW32Pe();
virtual int getFormat() const { return UPX_F_WIN32_PE; }
virtual const char *getName() const { return isrtm ? "rtm32/pe" : "win32/pe"; }
virtual const char *getFullName(const options_t *) const { return "i386-win32.pe"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_WIN32_PE; }
virtual const char *getName() const override { return isrtm ? "rtm32/pe" : "win32/pe"; }
virtual const char *getFullName(const options_t *) const override { return "i386-win32.pe"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
virtual bool handleForceOption();
virtual bool handleForceOption() override;
virtual void defineSymbols(unsigned ncsection, unsigned upxsection,
unsigned sizeof_oh, unsigned isize_isplit,
unsigned s1addr);
virtual void addNewRelocations(Reloc &, unsigned upxsection);
virtual void setOhDataBase(const pe_section_t *osection);
virtual void setOhHeaderSize(const pe_section_t *osection);
virtual void pack(OutputFile *fo);
unsigned s1addr) override;
virtual void addNewRelocations(Reloc &, unsigned upxsection) override;
virtual void setOhDataBase(const pe_section_t *osection) override;
virtual void setOhHeaderSize(const pe_section_t *osection) override;
virtual void pack(OutputFile *fo) override;
virtual bool canPack();
virtual bool canPack() override;
protected:
virtual int readFileHeader();
virtual int readFileHeader() override;
virtual void buildLoader(const Filter *ft);
virtual Linker* newLinker() const;
virtual void buildLoader(const Filter *ft) override;
virtual Linker* newLinker() const override;
};

26
src/p_w64pep.h
View File

@ -40,25 +40,25 @@ class PackW64Pep : public PeFile64
public:
PackW64Pep(InputFile *f);
virtual ~PackW64Pep();
virtual int getFormat() const { return UPX_F_WIN64_PEP; }
virtual const char *getName() const { return "win64/pe"; }
virtual const char *getFullName(const options_t *) const { return "amd64-win64.pe"; }
virtual const int *getCompressionMethods(int method, int level) const;
virtual const int *getFilters() const;
virtual int getFormat() const override { return UPX_F_WIN64_PEP; }
virtual const char *getName() const override { return "win64/pe"; }
virtual const char *getFullName(const options_t *) const override { return "amd64-win64.pe"; }
virtual const int *getCompressionMethods(int method, int level) const override;
virtual const int *getFilters() const override;
virtual bool handleForceOption();
virtual bool handleForceOption() override;
virtual void defineSymbols(unsigned ncsection, unsigned upxsection,
unsigned sizeof_oh, unsigned isize_isplit,
unsigned s1addr);
virtual void setOhDataBase(const pe_section_t *) {}
virtual void setOhHeaderSize(const pe_section_t *osection);
virtual void pack(OutputFile *fo);
unsigned s1addr) override;
virtual void setOhDataBase(const pe_section_t *) override {}
virtual void setOhHeaderSize(const pe_section_t *osection) override;
virtual void pack(OutputFile *fo) override;
virtual bool canPack();
virtual bool canPack() override;
protected:
virtual void buildLoader(const Filter *ft);
virtual Linker* newLinker() const;
virtual void buildLoader(const Filter *ft) override;
virtual Linker* newLinker() const override;
};