Revert "Switch to LLVM prebuilt tools for ART gtests"

This reverts commit 8070443ce4b31a6787c22490f18f838f8f6ed4be.

Reason for revert: Failing on chrome buildbots.
Test: None
Bug: 137817558

Change-Id: I4cbb4898e859ce33560592dd63cbf4a413048662

1 files changed, 115 insertions, 128 deletions

diff --git a/compiler/debug/dwarf/dwarf_test.cc b/compiler/debug/dwarf/dwarf_test.cc
index 062cfc9d2c..95d9e93ec6 100644
--- a/compiler/debug/dwarf/dwarf_test.cc
+++ b/compiler/debug/dwarf/dwarf_test.cc
@@ -36,87 +36,86 @@ TEST_F(DwarfTest, DebugFrame) {
   const int offset = 40000;
   ASSERT_EQ(UnsignedLeb128Size(offset / 4), 2u);
   ASSERT_EQ(SignedLeb128Size(offset / 4), 3u);
+  DW_CHECK("Data alignment factor: -4");
   const Reg reg(6);
 
   // Test the opcodes in the order mentioned in the spec.
   // There are usually several encoding variations of each opcode.
   DebugFrameOpCodeWriter<> opcodes;
-  DW_CHECK(".debug_frame contents:");
   DW_CHECK("FDE");
-  DW_CHECK_NEXT("DW_CFA_nop:");  // TODO: Why is a nop here.
   int pc = 0;
   for (int i : {0, 1, 0x3F, 0x40, 0xFF, 0x100, 0xFFFF, 0x10000}) {
     pc += i;
     opcodes.AdvancePC(pc);
   }
-  DW_CHECK_NEXT("DW_CFA_advance_loc: 1");
-  DW_CHECK_NEXT("DW_CFA_advance_loc: 63");
-  DW_CHECK_NEXT("DW_CFA_advance_loc1: 64");
-  DW_CHECK_NEXT("DW_CFA_advance_loc1: 255");
-  DW_CHECK_NEXT("DW_CFA_advance_loc2: 256");
-  DW_CHECK_NEXT("DW_CFA_advance_loc2: 65535");
-  DW_CHECK_NEXT("DW_CFA_advance_loc4: 65536");
+  DW_CHECK_NEXT("DW_CFA_advance_loc: 1 to 01000001");
+  DW_CHECK_NEXT("DW_CFA_advance_loc: 63 to 01000040");
+  DW_CHECK_NEXT("DW_CFA_advance_loc1: 64 to 01000080");
+  DW_CHECK_NEXT("DW_CFA_advance_loc1: 255 to 0100017f");
+  DW_CHECK_NEXT("DW_CFA_advance_loc2: 256 to 0100027f");
+  DW_CHECK_NEXT("DW_CFA_advance_loc2: 65535 to 0101027e");
+  DW_CHECK_NEXT("DW_CFA_advance_loc4: 65536 to 0102027e");
   opcodes.DefCFA(reg, offset);
-  DW_CHECK_NEXT("DW_CFA_def_cfa: reg6 +40000");
+  DW_CHECK_NEXT("DW_CFA_def_cfa: r6 (esi) ofs 40000");
   opcodes.DefCFA(reg, -offset);
-  DW_CHECK_NEXT("DW_CFA_def_cfa_sf: reg6 -40000");
+  DW_CHECK_NEXT("DW_CFA_def_cfa_sf: r6 (esi) ofs -40000");
   opcodes.DefCFARegister(reg);
-  DW_CHECK_NEXT("DW_CFA_def_cfa_register: reg6");
+  DW_CHECK_NEXT("DW_CFA_def_cfa_register: r6 (esi)");
   opcodes.DefCFAOffset(offset);
-  DW_CHECK_NEXT("DW_CFA_def_cfa_offset: +40000");
+  DW_CHECK_NEXT("DW_CFA_def_cfa_offset: 40000");
   opcodes.DefCFAOffset(-offset);
   DW_CHECK_NEXT("DW_CFA_def_cfa_offset_sf: -40000");
-  uint8_t expr[] = { /*nop*/ 0x96 };
+  uint8_t expr[] = { 0 };
   opcodes.DefCFAExpression(expr, arraysize(expr));
-  DW_CHECK_NEXT("DW_CFA_def_cfa_expression: DW_OP_nop");
+  DW_CHECK_NEXT("DW_CFA_def_cfa_expression");
   opcodes.Undefined(reg);
-  DW_CHECK_NEXT("DW_CFA_undefined: reg6");
+  DW_CHECK_NEXT("DW_CFA_undefined: r6 (esi)");
   opcodes.SameValue(reg);
-  DW_CHECK_NEXT("DW_CFA_same_value: reg6");
+  DW_CHECK_NEXT("DW_CFA_same_value: r6 (esi)");
   opcodes.Offset(Reg(0x3F), -offset);
-  DW_CHECK_NEXT("DW_CFA_offset: reg63 -40000");
+  DW_CHECK_NEXT("DW_CFA_offset: r63 at cfa-40000");
   opcodes.Offset(Reg(0x40), -offset);
-  DW_CHECK_NEXT("DW_CFA_offset_extended: reg64 -40000");
+  DW_CHECK_NEXT("DW_CFA_offset_extended: r64 at cfa-40000");
   opcodes.Offset(Reg(0x40), offset);
-  DW_CHECK_NEXT("DW_CFA_offset_extended_sf: reg64 40000");
+  DW_CHECK_NEXT("DW_CFA_offset_extended_sf: r64 at cfa+40000");
   opcodes.ValOffset(reg, -offset);
-  DW_CHECK_NEXT("DW_CFA_val_offset: reg6 -40000");
+  DW_CHECK_NEXT("DW_CFA_val_offset: r6 (esi) at cfa-40000");
   opcodes.ValOffset(reg, offset);
-  DW_CHECK_NEXT("DW_CFA_val_offset_sf: reg6 40000");
+  DW_CHECK_NEXT("DW_CFA_val_offset_sf: r6 (esi) at cfa+40000");
   opcodes.Register(reg, Reg(1));
-  DW_CHECK_NEXT("DW_CFA_register: reg6 reg1");
+  DW_CHECK_NEXT("DW_CFA_register: r6 (esi) in r1 (ecx)");
   opcodes.Expression(reg, expr, arraysize(expr));
-  DW_CHECK_NEXT("DW_CFA_expression: reg6 DW_OP_nop");
+  DW_CHECK_NEXT("DW_CFA_expression: r6 (esi)");
   opcodes.ValExpression(reg, expr, arraysize(expr));
-  DW_CHECK_NEXT("DW_CFA_val_expression: reg6 DW_OP_nop");
+  DW_CHECK_NEXT("DW_CFA_val_expression: r6 (esi)");
   opcodes.Restore(Reg(0x3F));
-  DW_CHECK_NEXT("DW_CFA_restore: reg63");
+  DW_CHECK_NEXT("DW_CFA_restore: bad register: r63");
   opcodes.Restore(Reg(0x40));
-  DW_CHECK_NEXT("DW_CFA_restore_extended: reg64");
+  DW_CHECK_NEXT("DW_CFA_restore_extended: bad register: r64");
   opcodes.Restore(reg);
-  DW_CHECK_NEXT("DW_CFA_restore: reg6");
+  DW_CHECK_NEXT("DW_CFA_restore: r6 (esi)");
   opcodes.RememberState();
-  DW_CHECK_NEXT("DW_CFA_remember_state:");
+  DW_CHECK_NEXT("DW_CFA_remember_state");
   opcodes.RestoreState();
-  DW_CHECK_NEXT("DW_CFA_restore_state:");
+  DW_CHECK_NEXT("DW_CFA_restore_state");
   opcodes.Nop();
-  DW_CHECK_NEXT("DW_CFA_nop:");
+  DW_CHECK_NEXT("DW_CFA_nop");
 
   // Also test helpers.
   opcodes.DefCFA(Reg(4), 100);  // ESP
-  DW_CHECK_NEXT("DW_CFA_def_cfa: reg4 +100");
+  DW_CHECK_NEXT("DW_CFA_def_cfa: r4 (esp) ofs 100");
   opcodes.AdjustCFAOffset(8);
-  DW_CHECK_NEXT("DW_CFA_def_cfa_offset: +108");
+  DW_CHECK_NEXT("DW_CFA_def_cfa_offset: 108");
   opcodes.RelOffset(Reg(0), 0);  // push R0
-  DW_CHECK_NEXT("DW_CFA_offset: reg0 -108");
+  DW_CHECK_NEXT("DW_CFA_offset: r0 (eax) at cfa-108");
   opcodes.RelOffset(Reg(1), 4);  // push R1
-  DW_CHECK_NEXT("DW_CFA_offset: reg1 -104");
+  DW_CHECK_NEXT("DW_CFA_offset: r1 (ecx) at cfa-104");
   opcodes.RelOffsetForMany(Reg(2), 8, 1 | (1 << 3), 4);  // push R2 and R5
-  DW_CHECK_NEXT("DW_CFA_offset: reg2 -100");
-  DW_CHECK_NEXT("DW_CFA_offset: reg5 -96");
+  DW_CHECK_NEXT("DW_CFA_offset: r2 (edx) at cfa-100");
+  DW_CHECK_NEXT("DW_CFA_offset: r5 (ebp) at cfa-96");
   opcodes.RestoreMany(Reg(2), 1 | (1 << 3));  // pop R2 and R5
-  DW_CHECK_NEXT("DW_CFA_restore: reg2");
-  DW_CHECK_NEXT("DW_CFA_restore: reg5");
+  DW_CHECK_NEXT("DW_CFA_restore: r2 (edx)");
+  DW_CHECK_NEXT("DW_CFA_restore: r5 (ebp)");
 
   DebugFrameOpCodeWriter<> initial_opcodes;
   WriteCIE(is64bit, Reg(is64bit ? 16 : 8), initial_opcodes, &debug_frame_data_);
@@ -127,7 +126,7 @@ TEST_F(DwarfTest, DebugFrame) {
            ArrayRef<const uint8_t>(*opcodes.data()),
            &debug_frame_data_);
 
-  CheckObjdumpOutput(is64bit, "-debug-frame");
+  CheckObjdumpOutput(is64bit, "-W");
 }
 
 TEST_F(DwarfTest, DISABLED_DebugFrame64) {
@@ -135,7 +134,6 @@ TEST_F(DwarfTest, DISABLED_DebugFrame64) {
   DebugFrameOpCodeWriter<> initial_opcodes;
   WriteCIE(is64bit, Reg(16), initial_opcodes, &debug_frame_data_);
   DebugFrameOpCodeWriter<> opcodes;
-  DW_CHECK(".debug_frame contents:");
   WriteFDE(is64bit,
            /* cie_pointer= */ 0,
            0x0100000000000000,
@@ -144,7 +142,7 @@ TEST_F(DwarfTest, DISABLED_DebugFrame64) {
            &debug_frame_data_);
   DW_CHECK("FDE cie=00000000 pc=100000000000000..300000000000000");
 
-  CheckObjdumpOutput(is64bit, "-debug-frame");
+  CheckObjdumpOutput(is64bit, "-W");
 }
 
 // Test x86_64 register mapping. It is the only non-trivial architecture.
@@ -152,29 +150,26 @@ TEST_F(DwarfTest, DISABLED_DebugFrame64) {
 TEST_F(DwarfTest, x86_64_RegisterMapping) {
   constexpr bool is64bit = true;
   DebugFrameOpCodeWriter<> opcodes;
-  DW_CHECK(".debug_frame contents:");
   for (int i = 0; i < 16; i++) {
     opcodes.RelOffset(Reg::X86_64Core(i), 0);
   }
   DW_CHECK("FDE");
-  DW_CHECK_NEXT("DW_CFA_nop:");  // TODO: Why is a nop here.
-  DW_CHECK_NEXT("DW_CFA_offset: reg0 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg2 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg1 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg3 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg7 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg6 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg4 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg5 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg8 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg9 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg10 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg11 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg12 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg13 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg14 0");
-  DW_CHECK_NEXT("DW_CFA_offset: reg15 0");
-
+  DW_CHECK_NEXT("DW_CFA_offset: r0 (rax)");
+  DW_CHECK_NEXT("DW_CFA_offset: r2 (rcx)");
+  DW_CHECK_NEXT("DW_CFA_offset: r1 (rdx)");
+  DW_CHECK_NEXT("DW_CFA_offset: r3 (rbx)");
+  DW_CHECK_NEXT("DW_CFA_offset: r7 (rsp)");
+  DW_CHECK_NEXT("DW_CFA_offset: r6 (rbp)");
+  DW_CHECK_NEXT("DW_CFA_offset: r4 (rsi)");
+  DW_CHECK_NEXT("DW_CFA_offset: r5 (rdi)");
+  DW_CHECK_NEXT("DW_CFA_offset: r8 (r8)");
+  DW_CHECK_NEXT("DW_CFA_offset: r9 (r9)");
+  DW_CHECK_NEXT("DW_CFA_offset: r10 (r10)");
+  DW_CHECK_NEXT("DW_CFA_offset: r11 (r11)");
+  DW_CHECK_NEXT("DW_CFA_offset: r12 (r12)");
+  DW_CHECK_NEXT("DW_CFA_offset: r13 (r13)");
+  DW_CHECK_NEXT("DW_CFA_offset: r14 (r14)");
+  DW_CHECK_NEXT("DW_CFA_offset: r15 (r15)");
   DebugFrameOpCodeWriter<> initial_opcodes;
   WriteCIE(is64bit, Reg(16), initial_opcodes, &debug_frame_data_);
   WriteFDE(is64bit,
@@ -184,67 +179,62 @@ TEST_F(DwarfTest, x86_64_RegisterMapping) {
            ArrayRef<const uint8_t>(*opcodes.data()),
            &debug_frame_data_);
 
-  CheckObjdumpOutput(is64bit, "-debug-frame");
+  CheckObjdumpOutput(is64bit, "-W");
 }
 
-TEST_F(DwarfTest, DebugLine) {
+TEST_F(DwarfTest, DISABLED_DebugLine) {
   const bool is64bit = false;
   const int code_factor_bits = 1;
   DebugLineOpCodeWriter<> opcodes(is64bit, code_factor_bits);
-  DW_CHECK(".debug_line contents:");
 
   std::vector<std::string> include_directories;
   include_directories.push_back("/path/to/source");
-  DW_CHECK("include_directories[  1] = \"/path/to/source\"");
+  DW_CHECK("/path/to/source");
 
   std::vector<FileEntry> files {
     { "file0.c", 0, 1000, 2000 },
     { "file1.c", 1, 1000, 2000 },
     { "file2.c", 1, 1000, 2000 },
   };
-  DW_CHECK_NEXT("file_names[  1]:");
-  DW_CHECK_NEXT("           name: \"file0.c\"");
-  DW_CHECK_NEXT("      dir_index: 0");
-  DW_CHECK_NEXT("       mod_time: 0x000003e8");
-  DW_CHECK_NEXT("         length: 0x000007d0");
-  DW_CHECK_NEXT("file_names[  2]:");
-  DW_CHECK_NEXT("           name: \"file1.c\"");
-  DW_CHECK_NEXT("      dir_index: 1");
-  DW_CHECK_NEXT("       mod_time: 0x000003e8");
-  DW_CHECK_NEXT("         length: 0x000007d0");
-  DW_CHECK_NEXT("file_names[  3]:");
-  DW_CHECK_NEXT("           name: \"file2.c\"");
-  DW_CHECK_NEXT("      dir_index: 1");
-  DW_CHECK_NEXT("       mod_time: 0x000003e8");
-  DW_CHECK_NEXT("         length: 0x000007d0");
-  DW_CHECK_NEXT("file_names[  4]:");
-  DW_CHECK_NEXT("           name: \"file.c\"");
-  DW_CHECK_NEXT("      dir_index: 0");
-  DW_CHECK_NEXT("       mod_time: 0x000003e8");
-  DW_CHECK_NEXT("         length: 0x000007d0");
+  DW_CHECK("1\t0\t1000\t2000\tfile0.c");
+  DW_CHECK_NEXT("2\t1\t1000\t2000\tfile1.c");
+  DW_CHECK_NEXT("3\t1\t1000\t2000\tfile2.c");
 
+  DW_CHECK("Line Number Statements");
   opcodes.SetAddress(0x01000000);
-  opcodes.SetIsStmt(true);
+  DW_CHECK_NEXT("Extended opcode 2: set Address to 0x1000000");
   opcodes.AddRow();
+  DW_CHECK_NEXT("Copy");
   opcodes.AdvancePC(0x01000100);
+  DW_CHECK_NEXT("Advance PC by 256 to 0x1000100");
   opcodes.SetFile(2);
+  DW_CHECK_NEXT("Set File Name to entry 2 in the File Name Table");
   opcodes.AdvanceLine(3);
+  DW_CHECK_NEXT("Advance Line by 2 to 3");
   opcodes.SetColumn(4);
+  DW_CHECK_NEXT("Set column to 4");
+  opcodes.SetIsStmt(true);
+  DW_CHECK_NEXT("Set is_stmt to 1");
   opcodes.SetIsStmt(false);
+  DW_CHECK_NEXT("Set is_stmt to 0");
   opcodes.SetBasicBlock();
+  DW_CHECK_NEXT("Set basic block");
   opcodes.SetPrologueEnd();
+  DW_CHECK_NEXT("Set prologue_end to true");
   opcodes.SetEpilogueBegin();
+  DW_CHECK_NEXT("Set epilogue_begin to true");
   opcodes.SetISA(5);
+  DW_CHECK_NEXT("Set ISA to 5");
   opcodes.EndSequence();
+  DW_CHECK_NEXT("Extended opcode 1: End of Sequence");
   opcodes.DefineFile("file.c", 0, 1000, 2000);
-  DW_CHECK_NEXT("Address            Line   Column File   ISA Discriminator Flags");
-  DW_CHECK_NEXT("------------------ ------ ------ ------ --- ------------- -------------");
-  DW_CHECK_NEXT("0x0000000001000000      1      0      1   0             0  is_stmt");
-  DW_CHECK_NEXT("0x0000000001000100      3      4      2   5             0  basic_block prologue_end epilogue_begin end_sequence");
+  DW_CHECK_NEXT("Extended opcode 3: define new File Table entry");
+  DW_CHECK_NEXT("Entry\tDir\tTime\tSize\tName");
+  DW_CHECK_NEXT("1\t0\t1000\t2000\tfile.c");
 
   WriteDebugLineTable(include_directories, files, opcodes, &debug_line_data_);
 
-  CheckObjdumpOutput(is64bit, "-debug-line");
+  CheckObjdumpOutput(is64bit, "-W");
 }
 
 // DWARF has special one byte codes which advance PC and line at the same time.
@@ -256,11 +246,11 @@ TEST_F(DwarfTest, DebugLineSpecialOpcodes) {
   DebugLineOpCodeWriter<> opcodes(is64bit, code_factor_bits);
   opcodes.SetAddress(pc);
   size_t num_rows = 0;
-  DW_CHECK(".debug_line contents:");
-  DW_CHECK("file_names[  1]:");
-  DW_CHECK("           name: \"file.c\"");
-  DW_CHECK("Address            Line   Column File   ISA Discriminator Flags");
-  DW_CHECK("------------------ ------ ------ ------ --- ------------- -------------");
+  DW_CHECK("Line Number Statements:");
+  DW_CHECK("Special opcode");
+  DW_CHECK("Advance PC by constant");
+  DW_CHECK("Decoded dump of debug contents of section .debug_line:");
+  DW_CHECK("Line number    Starting address");
   for (int addr_delta = 0; addr_delta < 80; addr_delta += 2) {
     for (int line_delta = 16; line_delta >= -16; --line_delta) {
       pc += addr_delta;
@@ -270,74 +260,71 @@ TEST_F(DwarfTest, DebugLineSpecialOpcodes) {
       ASSERT_EQ(opcodes.CurrentAddress(), pc);
       ASSERT_EQ(opcodes.CurrentLine(), line);
       char expected[1024];
-      sprintf(expected, "0x%016x %6i      0      1   0             0", pc, line);
+      sprintf(expected, "%i           0x%x", line, pc);
       DW_CHECK_NEXT(expected);
     }
   }
-  opcodes.EndSequence();
   EXPECT_LT(opcodes.data()->size(), num_rows * 3);
 
   std::vector<std::string> directories;
   std::vector<FileEntry> files = { { "file.c", 0, 1000, 2000 } };
   WriteDebugLineTable(directories, files, opcodes, &debug_line_data_);
 
-  CheckObjdumpOutput(is64bit, "-debug-line");
+  CheckObjdumpOutput(is64bit, "-W -WL");
 }
 
 TEST_F(DwarfTest, DebugInfo) {
   constexpr bool is64bit = false;
-
   DebugAbbrevWriter<> debug_abbrev(&debug_abbrev_data_);
-  DW_CHECK(".debug_abbrev contents:");
-  DW_CHECK_NEXT("Abbrev table for offset: 0x00000000");
-  DW_CHECK_NEXT("[1] DW_TAG_compile_unit DW_CHILDREN_yes");
-  DW_CHECK_NEXT(" DW_AT_producer DW_FORM_strp");
-  DW_CHECK_NEXT(" DW_AT_low_pc DW_FORM_addr");
-  DW_CHECK_NEXT(" DW_AT_high_pc DW_FORM_addr");
-  DW_CHECK_NEXT("[2] DW_TAG_subprogram DW_CHILDREN_no");
-  DW_CHECK_NEXT(" DW_AT_name DW_FORM_strp");
-  DW_CHECK_NEXT(" DW_AT_low_pc DW_FORM_addr");
-  DW_CHECK_NEXT(" DW_AT_high_pc DW_FORM_addr");
-  DW_CHECK_NEXT("[3] DW_TAG_compile_unit DW_CHILDREN_no");
-
   DebugInfoEntryWriter<> info(is64bit, &debug_abbrev);
-  DW_CHECK(".debug_info contents:");
+  DW_CHECK("Contents of the .debug_info section:");
   info.StartTag(dwarf::DW_TAG_compile_unit);
-  DW_CHECK_NEXT("Compile Unit: length = 0x00000030 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x04");
-  DW_CHECK_NEXT("DW_TAG_compile_unit");
+  DW_CHECK("Abbrev Number: 1 (DW_TAG_compile_unit)");
   info.WriteStrp(dwarf::DW_AT_producer, "Compiler name", &debug_str_data_);
-  DW_CHECK_NEXT("  DW_AT_producer (\"Compiler name\")");
+  DW_CHECK_NEXT("DW_AT_producer    : (indirect string, offset: 0x0): Compiler name");
   info.WriteAddr(dwarf::DW_AT_low_pc, 0x01000000);
-  DW_CHECK_NEXT("  DW_AT_low_pc (0x0000000001000000)");
+  DW_CHECK_NEXT("DW_AT_low_pc      : 0x1000000");
   info.WriteAddr(dwarf::DW_AT_high_pc, 0x02000000);
-  DW_CHECK_NEXT("  DW_AT_high_pc (0x0000000002000000)");
+  DW_CHECK_NEXT("DW_AT_high_pc     : 0x2000000");
   info.StartTag(dwarf::DW_TAG_subprogram);
-  DW_CHECK_NEXT("  DW_TAG_subprogram");
+  DW_CHECK("Abbrev Number: 2 (DW_TAG_subprogram)");
   info.WriteStrp(dwarf::DW_AT_name, "Foo", &debug_str_data_);
-  DW_CHECK_NEXT("    DW_AT_name (\"Foo\")");
+  DW_CHECK_NEXT("DW_AT_name        : (indirect string, offset: 0xe): Foo");
   info.WriteAddr(dwarf::DW_AT_low_pc, 0x01010000);
-  DW_CHECK_NEXT("    DW_AT_low_pc (0x0000000001010000)");
+  DW_CHECK_NEXT("DW_AT_low_pc      : 0x1010000");
   info.WriteAddr(dwarf::DW_AT_high_pc, 0x01020000);
-  DW_CHECK_NEXT("    DW_AT_high_pc (0x0000000001020000)");
+  DW_CHECK_NEXT("DW_AT_high_pc     : 0x1020000");
   info.EndTag();  // DW_TAG_subprogram
   info.StartTag(dwarf::DW_TAG_subprogram);
-  DW_CHECK_NEXT("  DW_TAG_subprogram");
+  DW_CHECK("Abbrev Number: 2 (DW_TAG_subprogram)");
   info.WriteStrp(dwarf::DW_AT_name, "Bar", &debug_str_data_);
-  DW_CHECK_NEXT("    DW_AT_name (\"Bar\")");
+  DW_CHECK_NEXT("DW_AT_name        : (indirect string, offset: 0x12): Bar");
   info.WriteAddr(dwarf::DW_AT_low_pc, 0x01020000);
-  DW_CHECK_NEXT("    DW_AT_low_pc (0x0000000001020000)");
+  DW_CHECK_NEXT("DW_AT_low_pc      : 0x1020000");
   info.WriteAddr(dwarf::DW_AT_high_pc, 0x01030000);
-  DW_CHECK_NEXT("    DW_AT_high_pc (0x0000000001030000)");
+  DW_CHECK_NEXT("DW_AT_high_pc     : 0x1030000");
   info.EndTag();  // DW_TAG_subprogram
   info.EndTag();  // DW_TAG_compile_unit
-  DW_CHECK_NEXT("  NULL");
   // Test that previous list was properly terminated and empty children.
   info.StartTag(dwarf::DW_TAG_compile_unit);
   info.EndTag();  // DW_TAG_compile_unit
 
+  // The abbrev table is just side product, but check it as well.
+  DW_CHECK("Abbrev Number: 3 (DW_TAG_compile_unit)");
+  DW_CHECK("Contents of the .debug_abbrev section:");
+  DW_CHECK("1      DW_TAG_compile_unit    [has children]");
+  DW_CHECK_NEXT("DW_AT_producer     DW_FORM_strp");
+  DW_CHECK_NEXT("DW_AT_low_pc       DW_FORM_addr");
+  DW_CHECK_NEXT("DW_AT_high_pc      DW_FORM_addr");
+  DW_CHECK("2      DW_TAG_subprogram    [no children]");
+  DW_CHECK_NEXT("DW_AT_name         DW_FORM_strp");
+  DW_CHECK_NEXT("DW_AT_low_pc       DW_FORM_addr");
+  DW_CHECK_NEXT("DW_AT_high_pc      DW_FORM_addr");
+  DW_CHECK("3      DW_TAG_compile_unit    [no children]");
+
   dwarf::WriteDebugInfoCU(/* debug_abbrev_offset= */ 0, info, &debug_info_data_);
 
-  CheckObjdumpOutput(is64bit, "-debug-info -debug-abbrev");
+  CheckObjdumpOutput(is64bit, "-W");
 }
 
 #endif  // ART_TARGET_ANDROID