Recompute ArchSpec core after MergeFrom

[labath]

Summary

MergeFrom was updating the architecture if the target triple did not
have it set. However, it was leaving the core field as invalid. This
resulted in assertion failures in core file tests as a missing core
meant we were unable to compute the address byte size properly.

Add a unit test for the new behaviour.

[labath]

Also remove the skipIfDarwin decorators, as they should work now -- there was
nothing darwin-specific about them, just our bots don't run assert builds at the
moment.

lldb/trunk/include/lldb/Core/ArchSpec.h

public:
   uint32_t GetFlags() const { return m_flags; }
 
   void SetFlags(uint32_t flags) { m_flags = flags; }
 
   void SetFlags(std::string elf_abi);
 
 protected:
   bool IsEqualTo(const ArchSpec &rhs, bool exact_match) const;
+  void UpdateCore();
 
   llvm::Triple m_triple;
   Core m_core = kCore_invalid;
   lldb::ByteOrder m_byte_order = lldb::eByteOrderInvalid;
 
   // Additional arch flags which we cannot get from triple and core
   // For MIPS these are application specific extensions like
   // micromips, mips16 etc.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/TestLinuxCore.py

def setUp(self):
         super(LinuxCoreTestCase, self).setUp()
         self._initial_platform = lldb.DBG.GetSelectedPlatform()
 
     def tearDown(self):
         lldb.DBG.SetSelectedPlatform(self._initial_platform)
         super(LinuxCoreTestCase, self).tearDown()
 
     @skipIf(oslist=['windows'])
-    @skipIfDarwin # <rdar://problem/31380097>, fails started happening with r299199
     @skipIf(triple='^mips')
     def test_i386(self):
         """Test that lldb can read the process information from an i386 linux core file."""
         self.do_test("linux-i386", self._i386_pid, self._i386_regions)
 
     def test_mips_o32(self):
         """Test that lldb can read the process information from an MIPS O32 linux core file."""
         self.do_test("linux-mipsel-gnuabio32", self._mips_o32_pid, self._mips_regions)
 
     def test_mips_n32(self):
         """Test that lldb can read the process information from an MIPS N32 linux core file """
         self.do_test("linux-mips64el-gnuabin32", self._mips64_n32_pid, self._mips_regions)
 
     def test_mips_n64(self):
         """Test that lldb can read the process information from an MIPS N64 linux core file """
         self.do_test("linux-mips64el-gnuabi64", self._mips64_n64_pid, self._mips_regions)
 
     @skipIf(oslist=['windows'])
-    @skipIfDarwin # <rdar://problem/31380097>, fails started happening with r299199
     @skipIf(triple='^mips')
     def test_x86_64(self):
         """Test that lldb can read the process information from an x86_64 linux core file."""
         self.do_test("linux-x86_64", self._x86_64_pid, self._x86_64_regions)
 
     @skipIf(oslist=['windows'])
-    @skipIfDarwin # <rdar://problem/31380097>, fails started happening with r299199
     @skipIf(triple='^mips')
     def test_s390x(self):
         """Test that lldb can read the process information from an s390x linux core file."""
         self.do_test("linux-s390x", self._s390x_pid, self._s390x_regions)
 
     @skipIf(oslist=['windows'])
-    @skipIfDarwin # <rdar://problem/31380097>, fails started happening with r299199
     @skipIf(triple='^mips')
     def test_same_pid_running(self):
         """Test that we read the information from the core correctly even if we have a running
         process with the same PID around"""
         try:
             shutil.copyfile("linux-x86_64.out", "linux-x86_64-pid.out")
             shutil.copyfile("linux-x86_64.core", "linux-x86_64-pid.core")
             with open("linux-x86_64-pid.core", "r+b") as f:
def test_same_pid_running(self):
                     f.seek(pid_offset)
                     f.write(struct.pack("<I", os.getpid()))
             self.do_test("linux-x86_64-pid", os.getpid(), self._x86_64_regions)
         finally:
             self.RemoveTempFile("linux-x86_64-pid.out")
             self.RemoveTempFile("linux-x86_64-pid.core")
 
     @skipIf(oslist=['windows'])
-    @skipIfDarwin # <rdar://problem/31380097>, fails started happening with r299199
     @skipIf(triple='^mips')
     def test_two_cores_same_pid(self):
         """Test that we handle the situation if we have two core files with the same PID
         around"""
         alttarget = self.dbg.CreateTarget("altmain.out")
         altprocess = alttarget.LoadCore("altmain.core")
         self.assertTrue(altprocess, PROCESS_IS_VALID)
         self.assertEqual(altprocess.GetNumThreads(), 1)
def test_two_cores_same_pid(self):
         self.assertTrue(error.Success())
         self.assertEqual(F, "_start")
 
         # without destroying this process, run the test which opens another core file with the
         # same pid
         self.do_test("linux-x86_64", self._x86_64_pid, self._x86_64_regions)
 
     @skipIf(oslist=['windows'])
-    @skipIfDarwin # <rdar://problem/31380097>, fails started happening with r299199
     @skipIf(triple='^mips')
     def test_FPR_SSE(self):
         # check x86_64 core file
         target = self.dbg.CreateTarget(None)
         self.assertTrue(target, VALID_TARGET)
         process = target.LoadCore("linux-fpr_sse_x86_64.core")
 
         values = {}

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/gcore/TestGCore.py

class GCoreTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     _initial_platform = lldb.DBG.GetSelectedPlatform()
 
     _i386_pid = 5586
     _x86_64_pid = 5669
 
     @skipIf(oslist=['windows'])
-    @skipIfDarwin # <rdar://problem/31380097>, fails started happening with r299199
     @skipIf(triple='^mips')
     def test_i386(self):
         """Test that lldb can read the process information from an i386 linux core file."""
         self.do_test("linux-i386", self._i386_pid)
 
     @skipIf(oslist=['windows'])
-    @skipIfDarwin # <rdar://problem/31380097>, fails started happening with r299199
     @skipIf(triple='^mips')
     def test_x86_64(self):
         """Test that lldb can read the process information from an x86_64 linux core file."""
         self.do_test("linux-x86_64", self._x86_64_pid)
 
     def do_test(self, filename, pid):
         target = self.dbg.CreateTarget("")
         process = target.LoadCore(filename + ".core")

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/thread_crash/TestLinuxCoreThreads.py

class LinuxCoreThreadsTestCase(TestBase):
     _i386_pid = 5193
     _x86_64_pid = 5222
 
     # Thread id for the failing thread.
     _i386_tid = 5195
     _x86_64_tid = 5250
 
     @skipIf(oslist=['windows'])
-    @skipIfDarwin # <rdar://problem/31380097>, fails started happening with r299199
     @skipIf(triple='^mips')
     def test_i386(self):
         """Test that lldb can read the process information from an i386 linux core file."""
         self.do_test("linux-i386", self._i386_pid, self._i386_tid)
 
     @skipIf(oslist=['windows'])
-    @skipIfDarwin # <rdar://problem/31380097>, fails started happening with r299199
     @skipIf(triple='^mips')
     def test_x86_64(self):
         """Test that lldb can read the process information from an x86_64 linux core file."""
         self.do_test("linux-x86_64", self._x86_64_pid, self._x86_64_tid)
 
     def do_test(self, filename, pid, tid):
         target = self.dbg.CreateTarget("")
         process = target.LoadCore(filename + ".core")

lldb/trunk/source/Core/ArchSpec.cpp

lldb::ByteOrder ArchSpec::GetByteOrder() const {
   return m_byte_order;
 }
 
 //===----------------------------------------------------------------------===//
 // Mutators.
 
 bool ArchSpec::SetTriple(const llvm::Triple &triple) {
   m_triple = triple;
-
-  llvm::StringRef arch_name(m_triple.getArchName());
-  const CoreDefinition *core_def = FindCoreDefinition(arch_name);
-  if (core_def) {
-    m_core = core_def->core;
-    // Set the byte order to the default byte order for an architecture.
-    // This can be modified if needed for cases when cores handle both
-    // big and little endian
-    m_byte_order = core_def->default_byte_order;
-  } else {
-    Clear();
-  }
-
+  UpdateCore();
   return IsValid();
 }
 
 bool lldb_private::ParseMachCPUDashSubtypeTriple(llvm::StringRef triple_str,
                                                  ArchSpec &arch) {
   // Accept "12-10" or "12.10" as cpu type/subtype
   if (triple_str.empty())
     return false;

 }
 
 void ArchSpec::MergeFrom(const ArchSpec &other) {
   if (TripleVendorIsUnspecifiedUnknown() &&
       !other.TripleVendorIsUnspecifiedUnknown())
     GetTriple().setVendor(other.GetTriple().getVendor());
   if (TripleOSIsUnspecifiedUnknown() && !other.TripleOSIsUnspecifiedUnknown())
     GetTriple().setOS(other.GetTriple().getOS());
-  if (GetTriple().getArch() == llvm::Triple::UnknownArch)
+  if (GetTriple().getArch() == llvm::Triple::UnknownArch) {
     GetTriple().setArch(other.GetTriple().getArch());
+    UpdateCore();
+  }
   if (GetTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
       !TripleVendorWasSpecified()) {
     if (other.TripleVendorWasSpecified())
       GetTriple().setEnvironment(other.GetTriple().getEnvironment());
   }
   // If this and other are both arm ArchSpecs and this ArchSpec is a generic
   // "some kind of arm"
   // spec but the other ArchSpec is a specific arm core, adopt the specific arm
if (core_match) {
 
     if (!isCompatibleEnvironment(lhs_triple_env, rhs_triple_env))
       return false;
     return true;
   }
   return false;
 }
 
+void ArchSpec::UpdateCore() {
+  llvm::StringRef arch_name(m_triple.getArchName());
+  const CoreDefinition *core_def = FindCoreDefinition(arch_name);
+  if (core_def) {
+    m_core = core_def->core;
+    // Set the byte order to the default byte order for an architecture.
+    // This can be modified if needed for cases when cores handle both
+    // big and little endian
+    m_byte_order = core_def->default_byte_order;
+  } else {
+    Clear();
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // Helper methods.
 
 void ArchSpec::CoreUpdated(bool update_triple) {
   const CoreDefinition *core_def = FindCoreDefinition(m_core);
   if (core_def) {
     if (update_triple)
       m_triple = llvm::Triple(core_def->name, "unknown", "unknown");

lldb/trunk/unittests/Core/ArchSpecTest.cpp

TEST(ArchSpecTest, TestSetTriple) {
   EXPECT_FALSE(AS.SetTriple("unknown-unknown-unknown"));
 
   AS = ArchSpec();
   EXPECT_FALSE(AS.SetTriple("unknown"));
 
   AS = ArchSpec();
   EXPECT_FALSE(AS.SetTriple(""));
 }
+
+TEST(ArchSpecTest, MergeFrom) {
+  ArchSpec A;
+  ArchSpec B("x86_64-pc-linux");
+
+  EXPECT_FALSE(A.IsValid());
+  ASSERT_TRUE(B.IsValid());
+  EXPECT_EQ(llvm::Triple::ArchType::x86_64, B.GetTriple().getArch());
+  EXPECT_EQ(llvm::Triple::VendorType::PC, B.GetTriple().getVendor());
+  EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
+  EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, B.GetCore());
+
+  A.MergeFrom(B);
+  ASSERT_TRUE(A.IsValid());
+  EXPECT_EQ(llvm::Triple::ArchType::x86_64, A.GetTriple().getArch());
+  EXPECT_EQ(llvm::Triple::VendorType::PC, A.GetTriple().getVendor());
+  EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
+  EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, A.GetCore());
+}