Revert of Update Crashpad to 6da9708e7cc93e2e1772439d51646e47583cb225

third_party/crashpad/crashpad/minidump/test/minidump_context_test_util.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "minidump/test/minidump_context_test_util.h"
 
 #include <string.h>
 #include <sys/types.h>
 
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
 #include "snapshot/cpu_context.h"
 #include "snapshot/test/test_cpu_context.h"
-#include "test/hex_string.h"
 
 namespace crashpad {
 namespace test {
 
 void InitializeMinidumpContextX86(MinidumpContextX86* context, uint32_t seed) {
   if (seed == 0) {
     memset(context, 0, sizeof(*context));
     context->context_flags = kMinidumpContextX86;
     return;
   }
@@ skipping 13 matching lines @@
   context->eip = value++;
   context->eflags = value++;
   context->cs = value++ & 0xffff;
   context->ds = value++ & 0xffff;
   context->es = value++ & 0xffff;
   context->fs = value++ & 0xffff;
   context->gs = value++ & 0xffff;
   context->ss = value++ & 0xffff;
 
   InitializeCPUContextX86Fxsave(&context->fxsave, &value);
-  CPUContextX86::FxsaveToFsave(context->fxsave, &context->fsave);
 
   context->dr0 = value++;
   context->dr1 = value++;
   context->dr2 = value++;
   context->dr3 = value++;
   value += 2;  // Minidumps don’t carry dr4 or dr5.
   context->dr6 = value++;
   context->dr7 = value++;
 
+  // Copy the values that are aliased between the fxsave area
+  // (context->extended_registers) and the floating-point save area
+  // (context->float_save).
+  context->float_save.control_word = context->fxsave.fcw;
+  context->float_save.status_word = context->fxsave.fsw;
+  context->float_save.tag_word = CPUContextX86::FxsaveToFsaveTagWord(
+      context->fxsave.fsw, context->fxsave.ftw, context->fxsave.st_mm);
+  context->float_save.error_offset = context->fxsave.fpu_ip;
+  context->float_save.error_selector = context->fxsave.fpu_cs;
+  context->float_save.data_offset = context->fxsave.fpu_dp;
+  context->float_save.data_selector = context->fxsave.fpu_ds;
+  for (size_t st_mm_index = 0;
+       st_mm_index < arraysize(context->fxsave.st_mm);
+       ++st_mm_index) {
+    for (size_t byte = 0;
+         byte < arraysize(context->fxsave.st_mm[st_mm_index].st);
+         ++byte) {
+      size_t st_index =
+          st_mm_index * arraysize(context->fxsave.st_mm[st_mm_index].st) + byte;
+      context->float_save.register_area[st_index] =
+          context->fxsave.st_mm[st_mm_index].st[byte];
+    }
+  }
+
   // Set this field last, because it has no analogue in CPUContextX86.
   context->float_save.spare_0 = value++;
 }
 
 void InitializeMinidumpContextAMD64(MinidumpContextAMD64* context,
                                     uint32_t seed) {
   if (seed == 0) {
     memset(context, 0, sizeof(*context));
     context->context_flags = kMinidumpContextAMD64;
     return;
@@ skipping 79 matching lines @@
   EXPECT_EQ(expected->reserved_2, observed->reserved_2);
   EXPECT_EQ(expected->fpu_dp, observed->fpu_dp);
   EXPECT_EQ(expected->fpu_ds, observed->fpu_ds);
   EXPECT_EQ(expected->reserved_3, observed->reserved_3);
   EXPECT_EQ(expected->mxcsr, observed->mxcsr);
   EXPECT_EQ(expected->mxcsr_mask, observed->mxcsr_mask);
   for (size_t st_mm_index = 0;
        st_mm_index < arraysize(expected->st_mm);
        ++st_mm_index) {
     SCOPED_TRACE(base::StringPrintf("st_mm_index %" PRIuS, st_mm_index));
-    EXPECT_EQ(BytesToHexString(expected->st_mm[st_mm_index].st,
-                               arraysize(expected->st_mm[st_mm_index].st)),
-              BytesToHexString(observed->st_mm[st_mm_index].st,
-                               arraysize(observed->st_mm[st_mm_index].st)));
-    EXPECT_EQ(
-        BytesToHexString(expected->st_mm[st_mm_index].st_reserved,
-                         arraysize(expected->st_mm[st_mm_index].st_reserved)),
-        BytesToHexString(observed->st_mm[st_mm_index].st_reserved,
-                         arraysize(observed->st_mm[st_mm_index].st_reserved)));
+    for (size_t byte = 0;
+         byte < arraysize(expected->st_mm[st_mm_index].st);
+         ++byte) {
+      EXPECT_EQ(expected->st_mm[st_mm_index].st[byte],
+                observed->st_mm[st_mm_index].st[byte]) << "byte " << byte;
+    }
+    for (size_t byte = 0;
+         byte < arraysize(expected->st_mm[st_mm_index].st_reserved);
+         ++byte) {
+      EXPECT_EQ(expected->st_mm[st_mm_index].st_reserved[byte],
+                observed->st_mm[st_mm_index].st_reserved[byte])
+          << "byte " << byte;
+    }
   }
   for (size_t xmm_index = 0;
        xmm_index < arraysize(expected->xmm);
        ++xmm_index) {
-    EXPECT_EQ(BytesToHexString(expected->xmm[xmm_index],
-                               arraysize(expected->xmm[xmm_index])),
-              BytesToHexString(observed->xmm[xmm_index],
-                               arraysize(observed->xmm[xmm_index])))
-        << "xmm_index " << xmm_index;
+    SCOPED_TRACE(base::StringPrintf("xmm_index %" PRIuS, xmm_index));
+    for (size_t byte = 0; byte < arraysize(expected->xmm[xmm_index]); ++byte) {
+      EXPECT_EQ(expected->xmm[xmm_index][byte], observed->xmm[xmm_index][byte])
+          << "byte " << byte;
+    }
   }
-  EXPECT_EQ(
-      BytesToHexString(expected->reserved_4, arraysize(expected->reserved_4)),
-      BytesToHexString(observed->reserved_4, arraysize(observed->reserved_4)));
-  EXPECT_EQ(
-      BytesToHexString(expected->available, arraysize(expected->available)),
-      BytesToHexString(observed->available, arraysize(observed->available)));
+  for (size_t byte = 0; byte < arraysize(expected->reserved_4); ++byte) {
+    EXPECT_EQ(expected->reserved_4[byte], observed->reserved_4[byte])
+        << "byte " << byte;
+  }
+  for (size_t byte = 0; byte < arraysize(expected->available); ++byte) {
+    EXPECT_EQ(expected->available[byte], observed->available[byte])
+        << "byte " << byte;
+  }
 }
 
 }  // namespace
 
 void ExpectMinidumpContextX86(
     uint32_t expect_seed, const MinidumpContextX86* observed, bool snapshot) {
   MinidumpContextX86 expected;
   InitializeMinidumpContextX86(&expected, expect_seed);
 
   EXPECT_EQ(expected.context_flags, observed->context_flags);
   EXPECT_EQ(expected.dr0, observed->dr0);
   EXPECT_EQ(expected.dr1, observed->dr1);
   EXPECT_EQ(expected.dr2, observed->dr2);
   EXPECT_EQ(expected.dr3, observed->dr3);
   EXPECT_EQ(expected.dr6, observed->dr6);
   EXPECT_EQ(expected.dr7, observed->dr7);
 
-  EXPECT_EQ(expected.fsave.fcw, observed->fsave.fcw);
-  EXPECT_EQ(expected.fsave.fsw, observed->fsave.fsw);
-  EXPECT_EQ(expected.fsave.ftw, observed->fsave.ftw);
-  EXPECT_EQ(expected.fsave.fpu_ip, observed->fsave.fpu_ip);
-  EXPECT_EQ(expected.fsave.fpu_cs, observed->fsave.fpu_cs);
-  EXPECT_EQ(expected.fsave.fpu_dp, observed->fsave.fpu_dp);
-  EXPECT_EQ(expected.fsave.fpu_ds, observed->fsave.fpu_ds);
-  for (size_t index = 0; index < arraysize(expected.fsave.st); ++index) {
-    EXPECT_EQ(BytesToHexString(expected.fsave.st[index],
-                               arraysize(expected.fsave.st[index])),
-              BytesToHexString(observed->fsave.st[index],
-                               arraysize(observed->fsave.st[index])))
-        << "index " << index;
+  EXPECT_EQ(expected.float_save.control_word,
+            observed->float_save.control_word);
+  EXPECT_EQ(expected.float_save.status_word, observed->float_save.status_word);
+  EXPECT_EQ(expected.float_save.tag_word, observed->float_save.tag_word);
+  EXPECT_EQ(expected.float_save.error_offset,
+            observed->float_save.error_offset);
+  EXPECT_EQ(expected.float_save.error_selector,
+            observed->float_save.error_selector);
+  EXPECT_EQ(expected.float_save.data_offset, observed->float_save.data_offset);
+  EXPECT_EQ(expected.float_save.data_selector,
+            observed->float_save.data_selector);
+  for (size_t index = 0;
+       index < arraysize(expected.float_save.register_area);
+       ++index) {
+    EXPECT_EQ(expected.float_save.register_area[index],
+              observed->float_save.register_area[index]) << "index " << index;
   }
   if (snapshot) {
     EXPECT_EQ(0u, observed->float_save.spare_0);
   } else {
     EXPECT_EQ(expected.float_save.spare_0, observed->float_save.spare_0);
   }
 
   EXPECT_EQ(expected.gs, observed->gs);
   EXPECT_EQ(expected.fs, observed->fs);
   EXPECT_EQ(expected.es, observed->es);
@@ skipping 109 matching lines @@
     EXPECT_EQ(expected.last_branch_to_rip, observed->last_branch_to_rip);
     EXPECT_EQ(expected.last_branch_from_rip, observed->last_branch_from_rip);
     EXPECT_EQ(expected.last_exception_to_rip, observed->last_exception_to_rip);
     EXPECT_EQ(expected.last_exception_from_rip,
               observed->last_exception_from_rip);
   }
 }
 
 }  // namespace test
 }  // namespace crashpad