[Courgette] Fold TrimLabels() into ParseDetectedExecutable().

TrimLabels() was a post-processing step after ParseDetectedExecutable().
Soon we'll do trimming earlier in the flow. However, existing code calls
TrimLabels() right after ParseDetectedExecutable(). This CL moves
TrimLabels() into ParseDetectedExecutable() to simplify the transition.

Existing flows that call ParseDetectedExecutable() are also inconsistent
in TrimLabel() usage; {-gen, -apply, -dis} do, and debugging flows
{-disadj, -gen1a, -gen1u} don't. This CL makes the debugging flows use
TrimLabel(). This side effect is likely positive, since it improves
consistently. Meanwhile, the actual impact is small: TrimLabels() is
active only for ELF ARM anyway.

Review URL: https://codereview.chromium.org/1615513002

Cr-Commit-Position: refs/heads/master@{#370916}

7 files changed, 18 insertions, 57 deletions

diff --git a/courgette/assembly_program.cc b/courgette/assembly_program.cc
index b2a01a0..20eee96 100644
--- a/courgette/assembly_program.cc
+++ b/courgette/assembly_program.cc
@@ -530,13 +530,6 @@ CheckBool AssemblyProgram::TrimLabels() {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-Status TrimLabels(AssemblyProgram* program) {
-  if (program->TrimLabels())
-    return C_OK;
-  else
-    return C_TRIM_FAILED;
-}
-
 Status Encode(AssemblyProgram* program, EncodedProgram** output) {
   *output = NULL;
   EncodedProgram *encoded = program->Encode();
diff --git a/courgette/assembly_program.h b/courgette/assembly_program.h
index 5fee6c2..45658ab 100644
--- a/courgette/assembly_program.h
+++ b/courgette/assembly_program.h
@@ -151,7 +151,8 @@ class AssemblyProgram {
   // otherwise returns NULL.
   Label* InstructionRel32Label(const Instruction* instruction) const;
 
-  // Trim underused labels
+  // Removes underused Labels. Thresholds used (may be 0, i.e., no trimming) is
+  // dependent on architecture. Returns true on success, and false otherwise.
   CheckBool TrimLabels();
 
  private:
diff --git a/courgette/courgette.h b/courgette/courgette.h
index 49cf8b2..5a98a46 100644
--- a/courgette/courgette.h
+++ b/courgette/courgette.h
@@ -109,10 +109,6 @@ Status DetectExecutableType(const void* buffer, size_t length,
 Status ParseDetectedExecutable(const void* buffer, size_t length,
                                AssemblyProgram** output);
 
-// Trims labels used fewer than a given number of times from an
-// assembly program in-place.
-Status TrimLabels(AssemblyProgram* program);
-
 // Converts |program| into encoded form, returning it as |*output|.
 // Returns C_OK if succeeded, otherwise returns an error status and
 // sets |*output| to NULL
diff --git a/courgette/courgette_tool.cc b/courgette/courgette_tool.cc
index 635dd91..c7e7196 100644
--- a/courgette/courgette_tool.cc
+++ b/courgette/courgette_tool.cc
@@ -82,14 +82,7 @@ void Disassemble(const base::FilePath& input_file,
                                          &program);
 
   if (parse_status != courgette::C_OK)
-    Problem("Can't parse input.");
-
-  // Trim labels below a certain threshold
-  const courgette::Status trim_status = TrimLabels(program);
-  if (trim_status != courgette::C_OK) {
-    courgette::DeleteAssemblyProgram(program);
-    Problem("Can't trim labels.");
-  }
+    Problem("Can't parse input (code = %d).", parse_status);
 
   courgette::EncodedProgram* encoded = NULL;
   const courgette::Status encode_status = Encode(program, &encoded);
@@ -172,7 +165,7 @@ void DisassembleAndAdjust(const base::FilePath& program_file,
                                          program_buffer.length(),
                                          &program);
   if (parse_program_status != courgette::C_OK)
-    Problem("Can't parse program input.");
+    Problem("Can't parse program input (code = %d).", parse_program_status);
 
   courgette::AssemblyProgram* model = NULL;
   const courgette::Status parse_model_status =
@@ -180,7 +173,7 @@ void DisassembleAndAdjust(const base::FilePath& program_file,
                                          model_buffer.length(),
                                          &model);
   if (parse_model_status != courgette::C_OK)
-    Problem("Can't parse model input.");
+    Problem("Can't parse model input (code = %d).", parse_model_status);
 
   const courgette::Status adjust_status = Adjust(*model, program);
   if (adjust_status != courgette::C_OK)
@@ -228,7 +221,7 @@ void DisassembleAdjustDiff(const base::FilePath& model_file,
                                          model_buffer.length(),
                                          &model);
   if (parse_model_status != courgette::C_OK)
-    Problem("Can't parse model input.");
+    Problem("Can't parse model input (code = %d).", parse_model_status);
 
   courgette::AssemblyProgram* program = NULL;
   const courgette::Status parse_program_status =
@@ -236,7 +229,7 @@ void DisassembleAdjustDiff(const base::FilePath& model_file,
                                          program_buffer.length(),
                                          &program);
   if (parse_program_status != courgette::C_OK)
-    Problem("Can't parse program input.");
+    Problem("Can't parse program input (code = %d).", parse_program_status);
 
   if (adjust) {
     const courgette::Status adjust_status = Adjust(*model, program);
diff --git a/courgette/disassembler.cc b/courgette/disassembler.cc
index 363d6e4..568114c 100644
--- a/courgette/disassembler.cc
+++ b/courgette/disassembler.cc
@@ -12,7 +12,7 @@
 #include <vector>
 
 #include "base/logging.h"
-
+#include "base/memory/scoped_ptr.h"
 #include "courgette/assembly_program.h"
 #include "courgette/courgette.h"
 #include "courgette/disassembler_elf_32_arm.h"
@@ -76,24 +76,22 @@ Status DetectExecutableType(const void* buffer, size_t length,
 
 Status ParseDetectedExecutable(const void* buffer, size_t length,
                                AssemblyProgram** output) {
-  *output = NULL;
-
-  Disassembler* disassembler = DetectDisassembler(buffer, length);
+  *output = nullptr;
 
-  if (!disassembler) {
+  scoped_ptr<Disassembler> disassembler(DetectDisassembler(buffer, length));
+  if (!disassembler)
     return C_INPUT_NOT_RECOGNIZED;
-  }
 
-  AssemblyProgram* program = new AssemblyProgram(disassembler->kind());
+  scoped_ptr<AssemblyProgram> program(
+      new AssemblyProgram(disassembler->kind()));
 
-  if (!disassembler->Disassemble(program)) {
-    delete program;
-    delete disassembler;
+  if (!disassembler->Disassemble(program.get()))
     return C_DISASSEMBLY_FAILED;
-  }
 
-  delete disassembler;
-  *output = program;
+  if (!program->TrimLabels())
+    return C_TRIM_FAILED;
+
+  *output = program.release();
   return C_OK;
 }
 
diff --git a/courgette/patch_generator_x86_32.h b/courgette/patch_generator_x86_32.h
index ac558be..1c56712 100644
--- a/courgette/patch_generator_x86_32.h
+++ b/courgette/patch_generator_x86_32.h
@@ -82,19 +82,6 @@ class PatchGeneratorX86_32 : public TransformationPatchGenerator {
       return new_parse_status;
     }
 
-    // Trim labels below a certain threshold
-    Status trim_old_status = TrimLabels(old_program);
-    if (trim_old_status != C_OK) {
-      DeleteAssemblyProgram(old_program);
-      return trim_old_status;
-    }
-
-    Status trim_new_status = TrimLabels(new_program);
-    if (trim_new_status != C_OK) {
-      DeleteAssemblyProgram(new_program);
-      return trim_new_status;
-    }
-
     EncodedProgram* old_encoded = NULL;
     Status old_encode_status = Encode(old_program, &old_encoded);
     if (old_encode_status != C_OK) {
diff --git a/courgette/patcher_x86_32.h b/courgette/patcher_x86_32.h
index 3461d79..28db059 100644
--- a/courgette/patcher_x86_32.h
+++ b/courgette/patcher_x86_32.h
@@ -55,13 +55,6 @@ class PatcherX86_32 : public TransformationPatcher {
     if (status != C_OK)
       return status;
 
-    // Trim labels below a certain threshold
-    Status trim_status = TrimLabels(program);
-    if (trim_status != C_OK) {
-      DeleteAssemblyProgram(program);
-      return trim_status;
-    }
-
     EncodedProgram* encoded = NULL;
     status = Encode(program, &encoded);
     DeleteAssemblyProgram(program);