register_state_check.h 5.73 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/*
 *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

Yaowu Xu's avatar
Yaowu Xu committed
11 12
#ifndef TEST_REGISTER_STATE_CHECK_H_
#define TEST_REGISTER_STATE_CHECK_H_
13

14 15
#include "third_party/googletest/src/include/gtest/gtest.h"
#include "./vpx_config.h"
16 17 18 19 20 21 22 23 24 25 26 27 28 29
#include "vpx/vpx_integer.h"

// ASM_REGISTER_STATE_CHECK(asm_function)
//   Minimally validates the environment pre & post function execution. This
//   variant should be used with assembly functions which are not expected to
//   fully restore the system state. See platform implementations of
//   RegisterStateCheck for details.
//
// API_REGISTER_STATE_CHECK(api_function)
//   Performs all the checks done by ASM_REGISTER_STATE_CHECK() and any
//   additional checks to ensure the environment is in a consistent state pre &
//   post function execution. This variant should be used with API functions.
//   See platform implementations of RegisterStateCheckXXX for details.
//
30 31

#if defined(_WIN64)
32

33
#undef NOMINMAX
34 35
#define NOMINMAX
#define WIN32_LEAN_AND_MEAN
36 37 38
#include <windows.h>
#include <winnt.h>

clang-format's avatar
clang-format committed
39
inline bool operator==(const M128A &lhs, const M128A &rhs) {
40 41 42 43 44 45 46 47 48 49 50 51 52 53
  return (lhs.Low == rhs.Low && lhs.High == rhs.High);
}

namespace libvpx_test {

// Compares the state of xmm[6-15] at construction with their state at
// destruction. These registers should be preserved by the callee on
// Windows x64.
class RegisterStateCheck {
 public:
  RegisterStateCheck() { initialized_ = StoreRegisters(&pre_context_); }
  ~RegisterStateCheck() { EXPECT_TRUE(Check()); }

 private:
clang-format's avatar
clang-format committed
54
  static bool StoreRegisters(CONTEXT *const context) {
55 56 57 58 59 60 61 62 63 64 65 66 67 68
    const HANDLE this_thread = GetCurrentThread();
    EXPECT_TRUE(this_thread != NULL);
    context->ContextFlags = CONTEXT_FLOATING_POINT;
    const bool context_saved = GetThreadContext(this_thread, context) == TRUE;
    EXPECT_TRUE(context_saved) << "GetLastError: " << GetLastError();
    return context_saved;
  }

  // Compares the register state. Returns true if the states match.
  bool Check() const {
    if (!initialized_) return false;
    CONTEXT post_context;
    if (!StoreRegisters(&post_context)) return false;

clang-format's avatar
clang-format committed
69 70
    const M128A *xmm_pre = &pre_context_.Xmm6;
    const M128A *xmm_post = &post_context.Xmm6;
71 72 73 74 75 76 77 78 79 80 81 82
    for (int i = 6; i <= 15; ++i) {
      EXPECT_EQ(*xmm_pre, *xmm_post) << "xmm" << i << " has been modified!";
      ++xmm_pre;
      ++xmm_post;
    }
    return !testing::Test::HasNonfatalFailure();
  }

  bool initialized_;
  CONTEXT pre_context_;
};

clang-format's avatar
clang-format committed
83 84 85 86 87
#define ASM_REGISTER_STATE_CHECK(statement)    \
  do {                                         \
    libvpx_test::RegisterStateCheck reg_check; \
    statement;                                 \
  } while (false)
88 89 90

}  // namespace libvpx_test

clang-format's avatar
clang-format committed
91 92
#elif defined(CONFIG_SHARED) && defined(HAVE_NEON_ASM) && \
    defined(CONFIG_VP10) && !CONFIG_SHARED && HAVE_NEON_ASM && CONFIG_VP10
93 94 95

extern "C" {
// Save the d8-d15 registers into store.
96
void vpx_push_neon(int64_t *store);
97 98 99 100 101 102 103 104 105 106 107 108 109 110
}

namespace libvpx_test {

// Compares the state of d8-d15 at construction with their state at
// destruction. These registers should be preserved by the callee on
// arm platform.
class RegisterStateCheck {
 public:
  RegisterStateCheck() { initialized_ = StoreRegisters(pre_store_); }
  ~RegisterStateCheck() { EXPECT_TRUE(Check()); }

 private:
  static bool StoreRegisters(int64_t store[8]) {
111
    vpx_push_neon(store);
112 113 114 115 116 117 118
    return true;
  }

  // Compares the register state. Returns true if the states match.
  bool Check() const {
    if (!initialized_) return false;
    int64_t post_store[8];
119
    vpx_push_neon(post_store);
120
    for (int i = 0; i < 8; ++i) {
clang-format's avatar
clang-format committed
121 122
      EXPECT_EQ(pre_store_[i], post_store[i]) << "d" << i + 8
                                              << " has been modified";
123 124 125 126 127 128 129 130
    }
    return !testing::Test::HasNonfatalFailure();
  }

  bool initialized_;
  int64_t pre_store_[8];
};

clang-format's avatar
clang-format committed
131 132 133 134 135
#define ASM_REGISTER_STATE_CHECK(statement)    \
  do {                                         \
    libvpx_test::RegisterStateCheck reg_check; \
    statement;                                 \
  } while (false)
136 137 138 139

}  // namespace libvpx_test

#else
140 141 142 143

namespace libvpx_test {

class RegisterStateCheck {};
144
#define ASM_REGISTER_STATE_CHECK(statement) statement
145 146 147 148 149

}  // namespace libvpx_test

#endif  // _WIN64

150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
#if ARCH_X86 || ARCH_X86_64
#if defined(__GNUC__)

namespace libvpx_test {

// Checks the FPU tag word pre/post execution to ensure emms has been called.
class RegisterStateCheckMMX {
 public:
  RegisterStateCheckMMX() {
    __asm__ volatile("fstenv %0" : "=rm"(pre_fpu_env_));
  }
  ~RegisterStateCheckMMX() { EXPECT_TRUE(Check()); }

 private:
  // Checks the FPU tag word pre/post execution, returning false if not cleared
  // to 0xffff.
  bool Check() const {
    EXPECT_EQ(0xffff, pre_fpu_env_[4])
        << "FPU was in an inconsistent state prior to call";

    uint16_t post_fpu_env[14];
    __asm__ volatile("fstenv %0" : "=rm"(post_fpu_env));
    EXPECT_EQ(0xffff, post_fpu_env[4])
        << "FPU was left in an inconsistent state after call";
    return !testing::Test::HasNonfatalFailure();
  }

  uint16_t pre_fpu_env_[14];
};

clang-format's avatar
clang-format committed
180 181 182 183 184
#define API_REGISTER_STATE_CHECK(statement)       \
  do {                                            \
    libvpx_test::RegisterStateCheckMMX reg_check; \
    ASM_REGISTER_STATE_CHECK(statement);          \
  } while (false)
185 186 187 188 189 190 191 192 193 194

}  // namespace libvpx_test

#endif  // __GNUC__
#endif  // ARCH_X86 || ARCH_X86_64

#ifndef API_REGISTER_STATE_CHECK
#define API_REGISTER_STATE_CHECK ASM_REGISTER_STATE_CHECK
#endif

Yaowu Xu's avatar
Yaowu Xu committed
195
#endif  // TEST_REGISTER_STATE_CHECK_H_