trogdor: update python scripts for python3

Change-Id: I46525243729c1dbcd30b346d4603452eea14ad9d
Signed-off-by: T Michael Turney <mturney@codeaurora.org>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/38558
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Julius Werner <jwerner@chromium.org>

5 files changed, 170 insertions, 153 deletions

diff --git a/util/qualcomm/createxbl.py b/util/qualcomm/createxbl.py
index 861cec9110..65d8eb9460 100755
--- a/util/qualcomm/createxbl.py
+++ b/util/qualcomm/createxbl.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 #============================================================================
 #
 #/** @file createxbl.py
@@ -238,9 +238,9 @@ def main():
   target_nonsec = target_base + "_combined_hash.mbn"
 
 
-  #print "Input file 1:", elf_inp_file1
-  #print "Input file 2:", elf_inp_file2
-  #print "Output file:", binary_out
+  #print("Input file 1:", elf_inp_file1)
+  #print("Input file 2:", elf_inp_file2)
+  #print("Output file:", binary_out)
 
   merge_elfs([],
              elf_inp_file1,
@@ -270,7 +270,7 @@ def main():
                                  secure_type = image_header_secflag,
                                  header_version = header_version )
     if rv:
-       raise RuntimeError, "Failed to run pboot_gen_elf"
+       raise RuntimeError("Failed to run pboot_gen_elf")
 
     # Create hash table header
     rv = mbn_tools.image_header([],
@@ -281,7 +281,7 @@ def main():
 				elf_file_name = source_elf,
 				header_version = header_version)
     if rv:
-       raise RuntimeError, "Failed to create image header for hash segment"
+       raise RuntimeError("Failed to create image header for hash segment")
 
     files_to_cat_in_order = [target_hash_hd, target_hash]
     mbn_tools.concat_files (target_nonsec, files_to_cat_in_order)
@@ -369,7 +369,7 @@ def merge_elfs(env,
 
   # Create a new ELF header for the output file
   if is_out_elf_64_bit:
-    out_elf_header = mbn_tools.Elf64_Ehdr('\0' * ELF64_HDR_SIZE)
+    out_elf_header = mbn_tools.Elf64_Ehdr(b'\0' * ELF64_HDR_SIZE)
     out_elf_header.e_phoff     = ELF64_HDR_SIZE
     out_elf_header.e_ehsize    = ELF64_HDR_SIZE
     out_elf_header.e_phentsize = ELF64_PHDR_SIZE
@@ -384,7 +384,7 @@ def merge_elfs(env,
 
     out_elf_header.e_entry     = elf_header1.e_entry
   else:
-    out_elf_header = mbn_tools.Elf32_Ehdr('\0' * ELF32_HDR_SIZE)
+    out_elf_header = mbn_tools.Elf32_Ehdr(b'\0' * ELF32_HDR_SIZE)
     out_elf_header.e_phoff     = ELF32_HDR_SIZE
     out_elf_header.e_ehsize    = ELF32_HDR_SIZE
     out_elf_header.e_phentsize = ELF32_PHDR_SIZE
@@ -401,7 +401,7 @@ def merge_elfs(env,
     # Address needs to be verified that it is not greater than 32 bits
     # as it is possible to go from a 64 bit elf to 32.
     if (elf_header1.e_entry > 0xFFFFFFFF):
-      print "ERROR: File 1's entry point is too large to convert."
+      print("ERROR: File 1's entry point is too large to convert.")
       exit()
     out_elf_header.e_entry     = elf_header1.e_entry
 
@@ -457,7 +457,7 @@ def merge_elfs(env,
     # Copy program header piece by piece to ensure possible conversion success
     if is_out_elf_64_bit == True:
       # Converting from 32 to 64 elf requires no data size validation
-      new_phdr = mbn_tools.Elf64_Phdr('\0' * ELF64_PHDR_SIZE)
+      new_phdr = mbn_tools.Elf64_Phdr(b'\0' * ELF64_PHDR_SIZE)
       new_phdr.p_type   = curr_phdr.p_type
       new_phdr.p_offset = segment_offset
       new_phdr.p_vaddr  = curr_phdr.p_vaddr
@@ -470,7 +470,7 @@ def merge_elfs(env,
       # Converting from 64 to 32 elf requires data size validation
       # Note that there is an option to discard a segment if it is only ZI
       # and its address is greater than 32 bits
-      new_phdr = mbn_tools.Elf32_Phdr('\0' * ELF32_PHDR_SIZE)
+      new_phdr = mbn_tools.Elf32_Phdr(b'\0' * ELF32_PHDR_SIZE)
       new_phdr.p_type   = curr_phdr.p_type
       new_phdr.p_offset = segment_offset
 
@@ -478,7 +478,7 @@ def merge_elfs(env,
         if (zi_oob_enabled == True) and (curr_phdr.p_filesz == 0):
           continue
         else:
-          print "ERROR: File 1 VAddr is too large for conversion."
+          print("ERROR: File 1 VAddr is too large for conversion.")
           exit()
       new_phdr.p_vaddr  = curr_phdr.p_vaddr
 
@@ -486,33 +486,33 @@ def merge_elfs(env,
         if (zi_oob_enabled == True) and (curr_phdr.p_filesz == 0):
           continue
         else:
-          print "ERROR: File 1 PAddr is too large for conversion."
+          print("ERROR: File 1 PAddr is too large for conversion.")
           exit()
       new_phdr.p_paddr  = curr_phdr.p_paddr
 
       if curr_phdr.p_filesz > 0xFFFFFFFF:
-        print "ERROR: File 1 Filesz is too large for conversion."
+        print("ERROR: File 1 Filesz is too large for conversion.")
         exit()
       new_phdr.p_filesz = curr_phdr.p_filesz
 
       if curr_phdr.p_memsz > 0xFFFFFFFF:
-        print "ERROR: File 1 Memsz is too large for conversion."
+        print("ERROR: File 1 Memsz is too large for conversion.")
         exit()
       new_phdr.p_memsz  = curr_phdr.p_memsz
 
       if curr_phdr.p_flags > 0xFFFFFFFF:
-        print "ERROR: File 1 Flags is too large for conversion."
+        print("ERROR: File 1 Flags is too large for conversion.")
         exit()
       new_phdr.p_flags  = curr_phdr.p_flags
 
       if curr_phdr.p_align > 0xFFFFFFFF:
-        print "ERROR: File 1 Align is too large for conversion."
+        print("ERROR: File 1 Align is too large for conversion.")
         exit()
       new_phdr.p_align  = curr_phdr.p_align
 
 
-    #print "i=",i
-    #print "phdr_offset=", phdr_offset
+    #print("i=",i)
+    #print("phdr_offset=", phdr_offset)
 
     # update output file location to next phdr location
     elf_out_fp.seek(phdr_offset)
@@ -521,14 +521,14 @@ def merge_elfs(env,
 
     inp_data_offset = curr_phdr.p_offset # used to read data from input file
 
-#    print "inp_data_offset="
-#    print inp_data_offset
+#    print("inp_data_offset=")
+#    print(inp_data_offset)
 #
-#    print "curr_phdr.p_offset="
-#    print curr_phdr.p_offset
+#    print("curr_phdr.p_offset=")
+#    print(curr_phdr.p_offset)
 #
-#    print "curr_phdr.p_filesz="
-#    print curr_phdr.p_filesz
+#    print("curr_phdr.p_filesz=")
+#    print(curr_phdr.p_filesz)
 
     # output current phdr
     if is_out_elf_64_bit == False:
@@ -555,7 +555,7 @@ def merge_elfs(env,
       # Copy program header piece by piece to ensure possible conversion success
       if is_out_elf_64_bit == True:
         # Converting from 32 to 64 elf requires no data size validation
-        new_phdr = mbn_tools.Elf64_Phdr('\0' * ELF64_PHDR_SIZE)
+        new_phdr = mbn_tools.Elf64_Phdr(b'\0' * ELF64_PHDR_SIZE)
         new_phdr.p_type   = curr_phdr.p_type
         new_phdr.p_offset = segment_offset
         new_phdr.p_vaddr  = curr_phdr.p_vaddr
@@ -568,7 +568,7 @@ def merge_elfs(env,
         # Converting from 64 to 32 elf requires data size validation
         # Note that there is an option to discard a segment if it is only ZI
         # and its address is greater than 32 bits
-        new_phdr = mbn_tools.Elf32_Phdr('\0' * ELF32_PHDR_SIZE)
+        new_phdr = mbn_tools.Elf32_Phdr(b'\0' * ELF32_PHDR_SIZE)
         new_phdr.p_type   = curr_phdr.p_type
         new_phdr.p_offset = segment_offset
 
@@ -576,7 +576,7 @@ def merge_elfs(env,
           if (zi_oob_enabled == True) and (curr_phdr.p_filesz == 0):
             continue
           else:
-            print "ERROR: File 2 VAddr is too large for conversion."
+            print("ERROR: File 2 VAddr is too large for conversion.")
             exit()
         new_phdr.p_vaddr  = curr_phdr.p_vaddr
 
@@ -584,33 +584,33 @@ def merge_elfs(env,
           if (zi_oob_enabled == True) and (curr_phdr.p_filesz == 0):
             continue
           else:
-            print "ERROR: File 2 PAddr is too large for conversion."
+            print("ERROR: File 2 PAddr is too large for conversion.")
             exit()
         new_phdr.p_paddr  = curr_phdr.p_paddr
 
         if curr_phdr.p_filesz > 0xFFFFFFFF:
-          print "ERROR: File 2 Filesz is too large for conversion."
+          print("ERROR: File 2 Filesz is too large for conversion.")
           exit()
         new_phdr.p_filesz = curr_phdr.p_filesz
 
         if curr_phdr.p_memsz > 0xFFFFFFFF:
-          print "ERROR: File 2 Memsz is too large for conversion."
+          print("ERROR: File 2 Memsz is too large for conversion.")
           exit()
         new_phdr.p_memsz  = curr_phdr.p_memsz
 
         if curr_phdr.p_flags > 0xFFFFFFFF:
-          print "ERROR: File 2 Flags is too large for conversion."
+          print("ERROR: File 2 Flags is too large for conversion.")
           exit()
         new_phdr.p_flags  = curr_phdr.p_flags
 
         if curr_phdr.p_align > 0xFFFFFFFF:
-          print "ERROR: File 2 Align is too large for conversion."
+          print("ERROR: File 2 Align is too large for conversion.")
           exit()
         new_phdr.p_align  = curr_phdr.p_align
 
 
-#     print "i=",i
-#     print "phdr_offset=", phdr_offset
+#     print("i=",i)
+#     print("phdr_offset=", phdr_offset)
 
       # update output file location to next phdr location
       elf_out_fp.seek(phdr_offset)
@@ -619,14 +619,14 @@ def merge_elfs(env,
 
       inp_data_offset = curr_phdr.p_offset # used to read data from input file
 
-#     print "inp_data_offset="
-#     print inp_data_offset
+#     print("inp_data_offset=")
+#     print(inp_data_offset)
 #
-#     print "curr_phdr.p_offset="
-#     print curr_phdr.p_offset
+#     print("curr_phdr.p_offset=")
+#     print(curr_phdr.p_offset)
 #
-#     print "curr_phdr.p_filesz="
-#     print curr_phdr.p_filesz
+#     print("curr_phdr.p_filesz=")
+#     print(curr_phdr.p_filesz)
 
       # output current phdr
       if is_out_elf_64_bit == False:
@@ -658,14 +658,14 @@ def merge_elfs(env,
         entry_seg_offset = phdr.p_offset
         break
     if entry_seg_offset == -1:
-      print "Error: Failed to find entry point in any segment!"
+      print("Error: Failed to find entry point in any segment!")
       exit()
     # magical equation for program header's phys and virt addr
     phys_virt_addr = entry_addr - entry_seg_offset
 
     if is_out_elf_64_bit:
       # Converting from 32 to 64 elf requires no data size validation
-      new_phdr = mbn_tools.Elf64_Phdr('\0' * ELF64_PHDR_SIZE)
+      new_phdr = mbn_tools.Elf64_Phdr(b'\0' * ELF64_PHDR_SIZE)
       new_phdr.p_type   = 0x1
       new_phdr.p_offset = segment_offset
       new_phdr.p_vaddr  = phys_virt_addr
@@ -683,7 +683,7 @@ def merge_elfs(env,
       # Converting from 64 to 32 elf requires data size validation
       # Don't discard the segment containing xbl_sec, simply error out
       # if the address is greater than 32 bits
-      new_phdr = mbn_tools.Elf32_Phdr('\0' * ELF32_PHDR_SIZE)
+      new_phdr = mbn_tools.Elf32_Phdr(b'\0' * ELF32_PHDR_SIZE)
       new_phdr.p_type   = 0x1 #
       new_phdr.p_offset = segment_offset
       if header_version >= 5:
@@ -696,13 +696,13 @@ def merge_elfs(env,
 
       if phys_virt_addr > 0xFFFFFFFF:
         if zi_oob_enabled == False or curr_phdr.p_filesz != 0:
-          print "ERROR: File xbl_sec VAddr or PAddr is too big for conversion."
+          print("ERROR: File xbl_sec VAddr or PAddr is too big for conversion.")
           exit()
       new_phdr.p_vaddr  = phys_virt_addr
       new_phdr.p_paddr  = phys_virt_addr
 
       if os.path.getsize(elf_in_file_xbl_sec) > 0xFFFFFFFF:
-        print "ERROR: File xbl_sec Filesz is too big for conversion."
+        print("ERROR: File xbl_sec Filesz is too big for conversion.")
         exit()
       new_phdr.p_filesz = os.path.getsize(elf_in_file_xbl_sec)
       new_phdr.p_memsz  = new_phdr.p_filesz
diff --git a/util/qualcomm/ipqheader.py b/util/qualcomm/ipqheader.py
index 7615146499..fe14e1f241 100755
--- a/util/qualcomm/ipqheader.py
+++ b/util/qualcomm/ipqheader.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 #
 # Copyright (c) 2013 The Linux Foundation. All rights reserved.
 #
@@ -97,7 +97,7 @@ def usage(msg=None):
     if msg != None:
         sys.stderr.write("%s: %s\n" % (PROG_NAME, msg))
 
-    print "Usage: %s <base-addr> <input-file> <output-file>" % PROG_NAME
+    print("Usage: %s <base-addr> <input-file> <output-file>" % PROG_NAME)
 
     if msg != None:
         exit(1)
diff --git a/util/qualcomm/mbn_tools.py b/util/qualcomm/mbn_tools.py
index 6008da5d82..b89044ffb9 100755
--- a/util/qualcomm/mbn_tools.py
+++ b/util/qualcomm/mbn_tools.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 #===============================================================================
 #
 # MBN TOOLS
@@ -100,24 +100,24 @@ ELFINFO_MAG0_INDEX        = 0
 ELFINFO_MAG1_INDEX        = 1
 ELFINFO_MAG2_INDEX        = 2
 ELFINFO_MAG3_INDEX        = 3
-ELFINFO_MAG0              = '\x7f'
-ELFINFO_MAG1              = 'E'
-ELFINFO_MAG2              = 'L'
-ELFINFO_MAG3              = 'F'
+ELFINFO_MAG0              = 127     # 0x7F
+ELFINFO_MAG1              = 69      # E
+ELFINFO_MAG2              = 76      # L
+ELFINFO_MAG3              = 70      # F
 ELFINFO_CLASS_INDEX       = 4
-ELFINFO_CLASS_32          = '\x01'
-ELFINFO_CLASS_64          = '\x02'
+ELFINFO_CLASS_32          = 1
+ELFINFO_CLASS_64          = 2
 ELFINFO_VERSION_INDEX     = 6
-ELFINFO_VERSION_CURRENT   = '\x01'
+ELFINFO_VERSION_CURRENT   = 1
 ELF_BLOCK_ALIGN           = 0x1000
 ALIGNVALUE_1MB             = 0x100000
 ALIGNVALUE_4MB            = 0x400000
-ELFINFO_DATA2LSB          = '\x01'
-ELFINFO_EXEC_ETYPE        = '\x02\x00'
-ELFINFO_ARM_MACHINETYPE   = '\x28\x00'
-ELFINFO_VERSION_EV_CURRENT = '\x01\x00\x00\x00'
+ELFINFO_DATA2LSB          = b'\x01'
+ELFINFO_EXEC_ETYPE        = b'\x02\x00'
+ELFINFO_ARM_MACHINETYPE   = b'\x28\x00'
+ELFINFO_VERSION_EV_CURRENT = b'\x01\x00\x00\x00'
 ELFINFO_SHOFF             = 0x00
-ELFINFO_PHNUM             = '\x01\x00'
+ELFINFO_PHNUM             = b'\x01\x00'
 ELFINFO_RESERVED          = 0x00
 
 # ELF Program Header Types
@@ -330,9 +330,9 @@ class Elf_Ehdr_common:
       self.e_version      = unpacked_data[3]
 
    def printValues(self):
-      print "ATTRIBUTE / VALUE"
-      for attr, value in self.__dict__.iteritems():
-         print attr, value
+      print("ATTRIBUTE / VALUE")
+      for attr, value in self.__dict__.items():
+         print(attr, value)
 
 
 
@@ -362,12 +362,16 @@ class Elf32_Ehdr:
       self.e_shstrndx     = unpacked_data[13]
 
    def printValues(self):
-      print "ATTRIBUTE / VALUE"
-      for attr, value in self.__dict__.iteritems():
-         print attr, value
+      print("ATTRIBUTE / VALUE")
+      for attr, value in self.__dict__.items():
+         print(attr, value)
 
    def getPackedData(self):
-      values = [self.e_ident,
+      if type(self.e_ident) == str:
+        packvalue = bytes(self.e_ident, 'utf-8')
+      else:
+        packvalue = self.e_ident
+      values = [packvalue,
                 self.e_type,
                 self.e_machine,
                 self.e_version,
@@ -406,9 +410,9 @@ class Elf32_Phdr:
       self.p_align        = unpacked_data[7]
 
    def printValues(self):
-      print "ATTRIBUTE / VALUE"
-      for attr, value in self.__dict__.iteritems():
-         print attr, value
+      print("ATTRIBUTE / VALUE")
+      for attr, value in self.__dict__.items():
+         print(attr, value)
 
    def getPackedData(self):
       values = [self.p_type,
@@ -449,12 +453,16 @@ class Elf64_Ehdr:
       self.e_shstrndx     = unpacked_data[13]
 
    def printValues(self):
-      print "ATTRIBUTE / VALUE"
-      for attr, value in self.__dict__.iteritems():
-         print attr, value
+      print("ATTRIBUTE / VALUE")
+      for attr, value in self.__dict__.items():
+         print(attr, value)
 
    def getPackedData(self):
-      values = [self.e_ident,
+      if type(self.e_ident) == str:
+        packvalue = bytes(self.e_ident, 'utf-8')
+      else:
+        packvalue = self.e_ident
+      values = [packvalue,
                 self.e_type,
                 self.e_machine,
                 self.e_version,
@@ -493,9 +501,9 @@ class Elf64_Phdr:
       self.p_align        = unpacked_data[7]
 
    def printValues(self):
-      print "ATTRIBUTE / VALUE"
-      for attr, value in self.__dict__.iteritems():
-         print attr, value
+      print("ATTRIBUTE / VALUE")
+      for attr, value in self.__dict__.items():
+         print(attr, value)
 
    def getPackedData(self):
       values = [self.p_type,
@@ -518,7 +526,7 @@ class SegmentInfo:
    def __init__(self):
       self.flag  = 0
    def printValues(self):
-      print 'Flag: ' + str(self.flag)
+      print('Flag: ' + str(self.flag))
 
 #----------------------------------------------------------------------------
 # Regular Boot Header Class
@@ -740,7 +748,7 @@ def generate_meta_data(env, meta_out_file_name, add_magic_num = False):
       xml_target_file.close()
    else:
       xml_target_file.close()
-      raise RuntimeError, "XML Size too large: " + str(xml_header_size)
+      raise RuntimeError("XML Size too large: " + str(xml_header_size))
 
 #----------------------------------------------------------------------------
 # encrypt_mbn
@@ -831,7 +839,7 @@ def create_elf_header( output_file_name,
                        is_elf_64_bit = False):
 
    if (output_file_name is None):
-      raise RuntimeError, "Requires a ELF header file"
+      raise RuntimeError("Requires a ELF header file")
 
    # Create a elf header and program header
    # Write the headers to the output file
@@ -922,13 +930,13 @@ def image_header(env, gen_dict,
 
    # Preliminary checks
    if (requires_preamble is True) and (preamble_file_name is None):
-      raise RuntimeError, "Image Header requires a preamble file"
+      raise RuntimeError("Image Header requires a preamble file")
 
    if (gen_dict['IMAGE_KEY_MBN_TYPE'] == 'elf') and (elf_file_name is None):
-      raise RuntimeError, "ELF Image Headers require an elf file"
+      raise RuntimeError("ELF Image Headers require an elf file")
 
    if (in_code_size is None) and (os.path.exists(code_file_name) is False):
-      raise RuntimeError, "Code size unavailable, and input file does not exist"
+      raise RuntimeError("Code size unavailable, and input file does not exist")
 
    # Initialize
    if in_code_size is not None:
@@ -1018,7 +1026,7 @@ def image_header(env, gen_dict,
       boot_header.writePackedData(target = output_file_name, write_full_hdr = write_full_hdr)
 
    else:
-      raise RuntimeError, "Header format not supported: " + str(header_format)
+      raise RuntimeError("Header format not supported: " + str(header_format))
    return 0
 
 
@@ -1066,15 +1074,15 @@ def pboot_gen_elf(env, elf_in_file_name,
    hashtable_shift = 0
 
    if elf_header.e_ident[ELFINFO_CLASS_INDEX] == ELFINFO_CLASS_64:
-      new_phdr = Elf64_Phdr('\0' * ELF64_PHDR_SIZE)
+      new_phdr = Elf64_Phdr(b'\0' * ELF64_PHDR_SIZE)
       elf_header_size = ELF64_HDR_SIZE
       is_elf64 = True
    else:
-      new_phdr = Elf32_Phdr('\0' * ELF32_PHDR_SIZE)
+      new_phdr = Elf32_Phdr(b'\0' * ELF32_PHDR_SIZE)
       elf_header_size = ELF32_HDR_SIZE
       is_elf64 = False
 
-   hash = '\0' * mi_prog_boot_digest_size
+   hash = b'\0' * mi_prog_boot_digest_size
    phdr_start = 0
    bytes_to_pad = 0
    hash_seg_end = 0
@@ -1083,7 +1091,7 @@ def pboot_gen_elf(env, elf_in_file_name,
    if elf_out_file_name is not None:
       # Assert limit on number of program headers in input ELF
       if num_phdrs > MAX_PHDR_COUNT:
-         raise RuntimeError, "Input ELF has exceeded maximum number of program headers"
+         raise RuntimeError("Input ELF has exceeded maximum number of program headers")
 
       # Create new program header for the ELF Header + Program Headers
       new_phdr.p_type = NULL_TYPE
@@ -1093,11 +1101,11 @@ def pboot_gen_elf(env, elf_in_file_name,
       elf_header.e_phnum += 2
 
       # Create an empty hash entry for PHDR_TYPE
-      hash_out_fp.write('\0' * mi_prog_boot_digest_size)
+      hash_out_fp.write(b'\0' * mi_prog_boot_digest_size)
       hashtable_size += mi_prog_boot_digest_size
 
       # Create an empty hash entry for the hash segment itself
-      hash_out_fp.write('\0' * mi_prog_boot_digest_size)
+      hash_out_fp.write(b'\0' * mi_prog_boot_digest_size)
       hashtable_size += mi_prog_boot_digest_size
 
    # Begin hash table generation
@@ -1117,7 +1125,7 @@ def pboot_gen_elf(env, elf_in_file_name,
 
          # Seg_size should be page aligned
          if (seg_size & (ELF_BLOCK_ALIGN - 1)) > 0:
-            raise RuntimeError, "seg_size: " + hex(seg_size) + " is not ELF page aligned!"
+            raise RuntimeError("seg_size: " + hex(seg_size) + " is not ELF page aligned!")
 
          off = seg_offset + seg_size
 
@@ -1134,7 +1142,7 @@ def pboot_gen_elf(env, elf_in_file_name,
             if MI_PBT_CHECK_FLAG_TYPE(curr_phdr.p_flags) is True:
                hash = generate_hash(fbuf, sha_algo)
             else:
-               hash = '\0' * mi_prog_boot_digest_size
+               hash = b'\0' * mi_prog_boot_digest_size
 
             # Write hash to file
             hash_out_fp.write(hash)
@@ -1153,7 +1161,7 @@ def pboot_gen_elf(env, elf_in_file_name,
          if (MI_PBT_CHECK_FLAG_TYPE(curr_phdr.p_flags) is True) and (data_len > 0):
             hash = generate_hash(file_buff, sha_algo)
          else:
-            hash = '\0' *  mi_prog_boot_digest_size
+            hash = b'\0' *  mi_prog_boot_digest_size
 
          # Write hash to file
          hash_out_fp.write(hash)
@@ -1179,9 +1187,9 @@ def pboot_gen_elf(env, elf_in_file_name,
      if (hash_seg_max_size is not None):
          # Error checking for hash segment size validity
         if hashtable_size > hash_seg_max_size:
-           raise RuntimeError, "Hash table exceeds maximum hash segment size: " + hex(hash_seg_max_size)
+           raise RuntimeError("Hash table exceeds maximum hash segment size: " + hex(hash_seg_max_size))
         if (hash_seg_max_size & (ELF_BLOCK_ALIGN-1)) is not 0:
-           raise RuntimeError, "Hash segment size passed is not ELF Block Aligned: " + hex(hash_seg_max_size)
+           raise RuntimeError("Hash segment size passed is not ELF Block Aligned: " + hex(hash_seg_max_size))
 
      # Check if hash physical address parameter was passed
      if last_phys_addr is not None:
@@ -1324,7 +1332,7 @@ def pboot_add_hash(env, elf_in_file_name,
       file_copy_offset(hash_tbl_fp, 0, elf_out_fp, hash_hdr_offset, hash_size)
 
    else:
-      raise RuntimeError, "Hash segment program header not found in file " + elf_in_file_name
+      raise RuntimeError("Hash segment program header not found in file " + elf_in_file_name)
 
    # Close files
    elf_in_fp.close()
@@ -1339,7 +1347,7 @@ def pboot_add_hash(env, elf_in_file_name,
 def image_auth(env, *args):
 
    if len(args) < 7 or len(args) > 8:
-      raise RuntimeError, "Usage Invalid"
+      raise RuntimeError("Usage Invalid")
 
    # Initialize File Names
    binary_in            = args[0]
@@ -1369,7 +1377,7 @@ def image_auth(env, *args):
       num_certs = num_certs + 1
 
    if (num_certs == 0):
-      raise RuntimeError, "Missing file(s) required for signing.\n"
+      raise RuntimeError("Missing file(s) required for signing.\n")
 
    # Create the Certificate Chain
    concat_files (cert_chain_out, cert_list)
@@ -1383,7 +1391,7 @@ def image_auth(env, *args):
       pad_file(cert_fp, bytes_to_pad, PAD_BYTE_1)
       cert_fp.close()
    else:
-      raise RuntimeError, "Certificate Size too large: " + str(cert_size)
+      raise RuntimeError("Certificate Size too large: " + str(cert_size))
 
    # Create the Final Signed Image File
    concat_files (signed_image_out, [binary_in, signature, cert_chain_out])
@@ -1488,7 +1496,7 @@ def modify_elf_flags(env, elf_in_file_name,
 
    # Check for corresponding number of segments
    if len(segment_list) is not elf_header.e_phnum:
-      raise RuntimeError, 'SCL file and ELF file have different number of segments!'
+      raise RuntimeError('SCL file and ELF file have different number of segments!')
 
    # Go to the start of the p_flag entry in the first program header
    file_offset = elf_header.e_phoff + phdr_flag_off
@@ -1595,11 +1603,11 @@ def generate_code_hash(env, elf_in_file_name):
           (curr_phdr.p_flags & PH_PERM_MASK) == PH_PERM_RX and
           curr_pages == code_seg_pages):
          if (code_seg_idx != -1):
-            raise RuntimeError, 'Multiple code segments match for: ' + code_seg_pages + ' pages'
+            raise RuntimeError('Multiple code segments match for: ' + code_seg_pages + ' pages')
          code_seg_idx = i
 
    if (code_seg_idx == -1):
-      raise RuntimeError, 'No matching code segment found'
+      raise RuntimeError('No matching code segment found')
 
    code_phdr = phdr_table[code_seg_idx]
 
@@ -1673,7 +1681,7 @@ def readSCL(filename, global_dict):
            # Token 1: Segment Name
            # Token 2: Start Address -- not used in MBN tools
            if len(tokens) < 2:
-              raise RuntimeError, 'SCL Segment Syntax malformed: ' + previous_line
+              raise RuntimeError('SCL Segment Syntax malformed: ' + previous_line)
 
            # Get the segment flags corresponding to the segment name description
            new_scl_entry.flag = getSegmentFlag(tokens[0].strip(strip_chars))
@@ -1720,7 +1728,7 @@ def getSegmentFlag(seg_info):
    UNSECURE = "UNSECURE"
 
    if seg_info is None or len(seg_info) is 0:
-      raise RuntimeError, 'Invalid segment information passed: ' + seg_info
+      raise RuntimeError('Invalid segment information passed: ' + seg_info)
 
    # Conditional checks and assignments of the corresponding segment flag values
    if NOTPAGEABLE in seg_info:
@@ -1782,7 +1790,7 @@ def getSegmentFlag(seg_info):
       ret_val = MI_PBT_ELF_UNSECURE_SEGMENT
 
    else:
-      raise RuntimeError, 'The segment name is wrongly defined in the SCL file: ' + seg_info
+      raise RuntimeError('The segment name is wrongly defined in the SCL file: ' + seg_info)
 
    return ret_val
 
@@ -1793,7 +1801,7 @@ def getSegmentFlag(seg_info):
 def pad_file(fp, num_bytes, value):
 
    if num_bytes < 0:
-      raise RuntimeError, "Number of bytes to pad must be greater than zero"
+      raise RuntimeError("Number of bytes to pad must be greater than zero")
 
    while num_bytes > 0:
       fp.write('%c' % value)
@@ -1862,7 +1870,7 @@ def generate_global_dict(env):
 def populate_dictionary(*args):
 
    if len(args) < 1:
-      raise RuntimeError, "At least 1 file must be specified as an input"
+      raise RuntimeError("At least 1 file must be specified as an input")
 
    global_dict = {}
    Fields = ["Define", "Key", "Value"]
@@ -1915,11 +1923,11 @@ def filter_dictionary(env, global_dict, **kwargs):
    # Check for Image Type
    # If IMAGE_TYPE parameter is not provided, raise error
    if not kwargs.has_key('IMAGE_TYPE'):
-      raise RuntimeError, "IMAGE_TYPE must be defined to use FilterDictionary."
+      raise RuntimeError("IMAGE_TYPE must be defined to use FilterDictionary.")
    else:
       image_type = kwargs.get('IMAGE_TYPE')
       if type(image_type) is not str:
-         raise RuntimeError, "IMAGE_TYPE must be of string type."
+         raise RuntimeError("IMAGE_TYPE must be of string type.")
 
    # Check for Flash Type
    # If FLASH_TYPE parameter is not provided, default to 'nand'
@@ -1928,7 +1936,7 @@ def filter_dictionary(env, global_dict, **kwargs):
    else:
       flash_type = kwargs.get('FLASH_TYPE')
       if type(flash_type) is not str:
-         raise RuntimeError, "FLASH_TYPE must be of string type. "
+         raise RuntimeError("FLASH_TYPE must be of string type. ")
 
    # Check for MBN Type
    # If MBN_TYPE parameter is not provided, default to 'elf'
@@ -1937,7 +1945,7 @@ def filter_dictionary(env, global_dict, **kwargs):
    else:
       mbn_type = kwargs.get('MBN_TYPE')
       if mbn_type != 'elf' and mbn_type != 'bin':
-         raise RuntimeError, "MBN_TYPE currently not supported: " + mbn_type
+         raise RuntimeError("MBN_TYPE currently not supported: " + mbn_type)
 
    # Check for Image ID
    # If IMAGE_ID parameter is not provided, default to ID 0
@@ -1946,7 +1954,7 @@ def filter_dictionary(env, global_dict, **kwargs):
    else:
       image_id = kwargs.get('IMAGE_ID')
       if type(image_id) is not int:
-         raise RuntimeError, "IMAGE_ID must be of integer type."
+         raise RuntimeError("IMAGE_ID must be of integer type.")
 
    # Initialize
    gen_dict = {}
@@ -1971,9 +1979,9 @@ def filter_dictionary(env, global_dict, **kwargs):
       if template_key_match in global_dict:
          image_dest = global_dict[template_key_match]
       else:
-         raise RuntimeError, "Builds file does not have IMAGE_KEY pair for: " + image_type
+         raise RuntimeError("Builds file does not have IMAGE_KEY pair for: " + image_type)
    else:
-      raise RuntimeError, "MBN_TYPE currently not supported: " + mbn_type
+      raise RuntimeError("MBN_TYPE currently not supported: " + mbn_type)
 
    # Assign generic dictionary key/value pairs
    gen_dict['IMAGE_KEY_IMAGE_ID'] = id
@@ -2004,7 +2012,7 @@ def filter_dictionary(env, global_dict, **kwargs):
       gen_dict['IMAGE_KEY_OEM_NUM_ROOT_CERTS'] = oem_num_root_certs
 
    else:
-      raise RuntimeError, "Invalid OEM root certificate configuration values"
+      raise RuntimeError("Invalid OEM root certificate configuration values")
 
    # Assign additional dictionary key/values pair as needed by tools.
 
@@ -2034,7 +2042,7 @@ def preprocess_elf_file(elf_file_name):
    elf_header = Elf_Ehdr_common(elf_fp.read(ELF_HDR_COMMON_SIZE))
 
    if verify_elf_header(elf_header) is False:
-      raise RuntimeError, "ELF file failed verification: " + elf_file_name
+      raise RuntimeError("ELF file failed verification: " + elf_file_name)
 
    elf_fp.seek(0)
 
@@ -2047,7 +2055,7 @@ def preprocess_elf_file(elf_file_name):
 
    # Verify ELF header information
    if verify_elf_header(elf_header) is False:
-      raise RuntimeError, "ELF file failed verification: " + elf_file_name
+      raise RuntimeError("ELF file failed verification: " + elf_file_name)
 
    # Get program header size
    phdr_size = elf_header.e_phentsize
@@ -2097,17 +2105,26 @@ def get_hash_address(elf_file_name):
 # Verify ELF header contents from an input ELF file
 #----------------------------------------------------------------------------
 def verify_elf_header(elf_header):
-   if (elf_header.e_ident[ELFINFO_MAG0_INDEX] != ELFINFO_MAG0) or \
-      (elf_header.e_ident[ELFINFO_MAG1_INDEX] != ELFINFO_MAG1) or \
-      (elf_header.e_ident[ELFINFO_MAG2_INDEX] != ELFINFO_MAG2) or \
-      (elf_header.e_ident[ELFINFO_MAG3_INDEX] != ELFINFO_MAG3) or \
-      ((elf_header.e_ident[ELFINFO_CLASS_INDEX] != ELFINFO_CLASS_64) and \
-       (elf_header.e_ident[ELFINFO_CLASS_INDEX] != ELFINFO_CLASS_32)) or \
-      (elf_header.e_ident[ELFINFO_VERSION_INDEX] != ELFINFO_VERSION_CURRENT):
-
+   if (elf_header.e_ident[ELFINFO_MAG0_INDEX] != ELFINFO_MAG0):
+      print("MAG0[{:d}]\n".format((elf_header.e_ident[ELFINFO_MAG0_INDEX])))
       return False
-   else:
-      return True
+   if (elf_header.e_ident[ELFINFO_MAG1_INDEX] != ELFINFO_MAG1):
+      print("MAG1[{:d}]\n".format((elf_header.e_ident[ELFINFO_MAG1_INDEX])))
+      return False
+   if (elf_header.e_ident[ELFINFO_MAG2_INDEX] != ELFINFO_MAG2):
+      print("MAG2[{:d}]\n".format((elf_header.e_ident[ELFINFO_MAG2_INDEX])))
+      return False
+   if (elf_header.e_ident[ELFINFO_MAG3_INDEX] != ELFINFO_MAG3):
+      print("MAG3[{:d}]\n".format((elf_header.e_ident[ELFINFO_MAG3_INDEX])))
+      return False
+   if ((elf_header.e_ident[ELFINFO_CLASS_INDEX] != ELFINFO_CLASS_64) and \
+       (elf_header.e_ident[ELFINFO_CLASS_INDEX] != ELFINFO_CLASS_32)):
+      print("ELFINFO_CLASS_INDEX[{:d}]\n".format((elf_header.e_ident[ELFINFO_CLASS_INDEX])))
+      return False
+   if (elf_header.e_ident[ELFINFO_VERSION_INDEX] != ELFINFO_VERSION_CURRENT):
+      print("ELFINFO_VERSION_INDEX[{:d}]\n".format((elf_header.e_ident[ELFINFO_VERSION_INDEX])))
+      return False
+   return True
 
 #----------------------------------------------------------------------------
 # Perform file copy given offsets and the number of bytes to copy
@@ -2159,9 +2176,9 @@ def initialize_hash_phdr(elf_in_file_name, hash_tbl_size, hdr_size, hdr_offset,
 
    # Update the hash table program header
    if is_elf64 is True:
-      hash_Phdr = Elf64_Phdr('\0'*ELF64_PHDR_SIZE)
+      hash_Phdr = Elf64_Phdr(b'\0'*ELF64_PHDR_SIZE)
    else:
-      hash_Phdr = Elf32_Phdr('\0'*ELF32_PHDR_SIZE)
+      hash_Phdr = Elf32_Phdr(b'\0'*ELF32_PHDR_SIZE)
    hash_Phdr.p_flags = MI_PBT_ELF_HASH_SEGMENT
    hash_Phdr.p_align = ELF_BLOCK_ALIGN
    hash_Phdr.p_offset = hash_hdr_offset
@@ -2243,7 +2260,7 @@ def OPEN(file_name, mode):
     try:
        fp = open(file_name, mode)
     except IOError:
-       raise RuntimeError, "The file could not be opened: " + file_name
+       raise RuntimeError("The file could not be opened: " + file_name)
 
     # File open has succeeded with the given mode, return the file object
     return fp
diff --git a/util/qualcomm/mbncat.py b/util/qualcomm/mbncat.py
index c4da265f80..622ed2dcbd 100755
--- a/util/qualcomm/mbncat.py
+++ b/util/qualcomm/mbncat.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 # Copyright (c) 2014, The Linux Foundation. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -75,27 +75,27 @@ class NorSbl:
         self.verbose = verbose
         self.mbn_file_names = []
         if self.verbose:
-            print 'Reading ' + sbl1
+            print('Reading ' + sbl1)
 
         try:
             self.sbl1 = open(sbl1, 'rb').read()
         except IOError as e:
-            print 'I/O error({0}): {1}'.format(e.errno, e.strerror)
+            print('I/O error({0}): {1}'.format(e.errno, e.strerror))
             raise
 
         (codeword, magic,  _) = struct.unpack_from(
             self.NOR_SBL1_HEADER, self.sbl1)
 
         if codeword != self.NOR_CODE_WORD:
-            print '\n\nError: Unexpected Codeword!'
-            print 'Codeword    : ' + ('0x%x' % self.NOR_CODE_WORD) + \
-                ' != ' + ('0x%x' % codeword)
+            print('\n\nError: Unexpected Codeword!')
+            print('Codeword    : ' + ('0x%x' % self.NOR_CODE_WORD) + \
+                ' != ' + ('0x%x' % codeword))
             sys.exit(-1)
 
         if magic != self.MAGIC_NUM:
-            print '\n\nError: Unexpected Magic!'
-            print 'Magic    : ' + ('0x%x' % self.MAGIC_NUM) + \
-                ' != ' + ('0x%x' % magic)
+            print('\n\nError: Unexpected Magic!')
+            print('Magic    : ' + ('0x%x' % self.MAGIC_NUM) + \
+                ' != ' + ('0x%x' % magic))
             sys.exit(-1)
 
     def Append(self, src):
@@ -119,10 +119,10 @@ class NorSbl:
         overflow = size % self.ALIGNMENT
         if overflow:
             pad_size = self.ALIGNMENT - overflow
-            pad = '\377' * pad_size
+            pad = b'\377' * pad_size
             outfile.write(pad)
             if self.verbose:
-                print 'Added %d byte padding' % pad_size
+                print('Added %d byte padding' % pad_size)
             return pad_size
         return 0
 
@@ -142,11 +142,11 @@ class NorSbl:
 
         for mbn_file_name in self.mbn_file_names:
             total_size += self.PadOutput(outfile, total_size)
-            mbn_file_data = open(mbn_file_name, 'r').read()
+            mbn_file_data = open(mbn_file_name, 'rb').read()
             outfile.write(mbn_file_data)
             if self.verbose:
-                print 'Added %s (%d bytes)' % (mbn_file_name,
-                                               len(mbn_file_data))
+                print('Added %s (%d bytes)' % (mbn_file_name,
+                                               len(mbn_file_data)))
             total_size += len(mbn_file_data)
 
         outfile.seek(28)
@@ -155,13 +155,13 @@ class NorSbl:
 
 
 def Usage(v):
-    print '%s: [-v] [-h] [-o Output MBN] sbl1 sbl2 [bootblock]' % (
-        os.path.basename(sys.argv[0]))
-    print
-    print 'Concatenates up to three mbn files: two SBLs and a coreboot bootblock'
-    print '    -h This message'
-    print '    -v verbose'
-    print '    -o Output file name, (default: %s)\n' % DEFAULT_OUTPUT_FILE_NAME
+    print('%s: [-v] [-h] [-o Output MBN] sbl1 sbl2 [bootblock]' % (
+        os.path.basename(sys.argv[0])))
+    print()
+    print('Concatenates up to three mbn files: two SBLs and a coreboot bootblock')
+    print('    -h This message')
+    print('    -v verbose')
+    print('    -o Output file name, (default: %s)\n' % DEFAULT_OUTPUT_FILE_NAME)
     sys.exit(v)
 
 def main():
diff --git a/util/qualcomm/qgpt.py b/util/qualcomm/qgpt.py
index 0b096b9cf5..fbf6d103df 100755
--- a/util/qualcomm/qgpt.py
+++ b/util/qualcomm/qgpt.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 #============================================================================
 #
 #/** @file qgpt.py