diff --git a/src/Makefile b/src/Makefile
index d340a4de..4b3e1acc 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -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
diff --git a/src/p_armpe.h b/src/p_armpe.h
index 3e9b6eb7..c758d81e 100644
--- a/src/p_armpe.h
+++ b/src/p_armpe.h
@@ -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;
 };
diff --git a/src/p_lx_elf.h b/src/p_lx_elf.h
index a749e90a..f2490755 100644
--- a/src/p_lx_elf.h
+++ b/src/p_lx_elf.h
@@ -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;
 };
 
 
diff --git a/src/p_lx_exc.h b/src/p_lx_exc.h
index 08f83fe7..46f88d12 100644
--- a/src/p_lx_exc.h
+++ b/src/p_lx_exc.h
@@ -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 */
 
diff --git a/src/p_lx_interp.h b/src/p_lx_interp.h
index 6529b079..5dccc4d4 100644
--- a/src/p_lx_interp.h
+++ b/src/p_lx_interp.h
@@ -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
 };
 
 
diff --git a/src/p_lx_sh.h b/src/p_lx_sh.h
index 55d62a7d..23568593 100644
--- a/src/p_lx_sh.h
+++ b/src/p_lx_sh.h
@@ -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
diff --git a/src/p_mach.h b/src/p_mach.h
index 3e2ef8d4..6a90ade9 100644
--- a/src/p_mach.h
+++ b/src/p_mach.h
@@ -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:
diff --git a/src/p_unix.h b/src/p_unix.h
index e7478ceb..2e90fc33 100644
--- a/src/p_unix.h
+++ b/src/p_unix.h
@@ -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 {
diff --git a/src/p_vmlinx.h b/src/p_vmlinx.h
index d8b97fc1..4bcf4f2a 100644
--- a/src/p_vmlinx.h
+++ b/src/p_vmlinx.h
@@ -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;
 };
 
 
diff --git a/src/p_vmlinz.h b/src/p_vmlinz.h
index 3f197bba..e994c76b 100644
--- a/src/p_vmlinz.h
+++ b/src/p_vmlinz.h
@@ -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;
diff --git a/src/p_w32pe.h b/src/p_w32pe.h
index fc28db6c..1994a552 100644
--- a/src/p_w32pe.h
+++ b/src/p_w32pe.h
@@ -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;
 };
 
 
diff --git a/src/p_w64pep.h b/src/p_w64pep.h
index 723f7b9c..128b9cd2 100644
--- a/src/p_w64pep.h
+++ b/src/p_w64pep.h
@@ -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;
 };