[Courgette] Refactor: Store Label Annotation in AssemblyProgram for patch generation.

courgette/courgette_tool.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 106 matching lines @@
   BufferedFileReader buffer(input_file, "input");
 
   courgette::ExecutableType type;
   size_t detected_length;
 
   DetectExecutableType(buffer.data(), buffer.length(), &type, &detected_length);
 
   // If the detection fails, we just fall back on UNKNOWN
   std::string format = "Unsupported";
 
-  switch (type)
-  {
+  switch (type) {
     case courgette::EXE_UNKNOWN:
       break;
 
     case courgette::EXE_WIN_32_X86:
       format = "Windows 32 PE";
       result = true;
       break;
 
     case courgette::EXE_ELF_32_X86:
       format = "ELF 32 X86";
@@ skipping 68 matching lines @@
 // original file's stream and the new file's stream.  This is completely
 // uninteresting to users, but it is handy for seeing how much each which
 // streams are contributing to the final file size.  Adjustment is optional.
 void DisassembleAdjustDiff(const base::FilePath& model_file,
                            const base::FilePath& program_file,
                            const base::FilePath& output_file_root,
                            bool adjust) {
   BufferedFileReader model_buffer(model_file, "old");
   BufferedFileReader program_buffer(program_file, "new");
 
+  auto parser = adjust ? courgette::ParseDetectedExecutableWithAnnotation
+                       : courgette::ParseDetectedExecutable;
+
   std::unique_ptr<courgette::AssemblyProgram> model;
   const courgette::Status parse_model_status =
-      courgette::ParseDetectedExecutable(model_buffer.data(),
-                                         model_buffer.length(), &model);
+      parser(model_buffer.data(), model_buffer.length(), &model);
   if (parse_model_status != courgette::C_OK)
     Problem("Can't parse model input (code = %d).", parse_model_status);
 
   std::unique_ptr<courgette::AssemblyProgram> program;
   const courgette::Status parse_program_status =
-      courgette::ParseDetectedExecutable(program_buffer.data(),
-                                         program_buffer.length(), &program);
+      parser(program_buffer.data(), program_buffer.length(), &program);
   if (parse_program_status != courgette::C_OK)
     Problem("Can't parse program input (code = %d).", parse_program_status);
 
   if (adjust) {
     const courgette::Status adjust_status = Adjust(*model, program.get());
     if (adjust_status != courgette::C_OK)
       Problem("Can't adjust program.");
   }
 
   std::unique_ptr<courgette::EncodedProgram> encoded_program;
@@ skipping 276 matching lines @@
         UsageProblem("-gen1[au] <old_file> <new_file> <patch_files_root>");
       DisassembleAdjustDiff(values[0], values[1], values[2],
                             cmd_spread_1_adjusted);
     } else {
       UsageProblem("No operation specified");
     }
   }
 
   return 0;
 }