char* find_jvm_so(const char* java_home_path)
{
char* path = malloc(sizeof(char) * MAX_LEN);
//java_home/lib/i386(amd64)/client(server)/libjvm.so
sprintf(path, "%s%clib%c%s%c%s%c%s", java_home_path, FILE_SEPARATOR, FILE_SEPARATOR,
get_arch(), FILE_SEPARATOR, JVM_CLIENT_SO_PATH, FILE_SEPARATOR, JVM_DLL);
if(check_file_exist(path))
return path;
sprintf(path, "%s%clib%c%s%c%s%c%s", java_home_path, FILE_SEPARATOR, FILE_SEPARATOR,
get_arch(), FILE_SEPARATOR, JVM_SERVER_SO_PATH, FILE_SEPARATOR, JVM_DLL);
if(check_file_exist(path))
return path;
//java_home/jre/lib/i386(amd64)/client(server)/libjvm.so
sprintf(path, "%s%cjre%clib%c%s%c%s%c%s", java_home_path, FILE_SEPARATOR, FILE_SEPARATOR, FILE_SEPARATOR,
get_arch(), FILE_SEPARATOR, JVM_CLIENT_SO_PATH, FILE_SEPARATOR, JVM_DLL);
if(check_file_exist(path))
return path;
sprintf(path, "%s%cjre%clib%c%s%c%s%c%s", java_home_path, FILE_SEPARATOR, FILE_SEPARATOR, FILE_SEPARATOR,
get_arch(), FILE_SEPARATOR, JVM_SERVER_SO_PATH, FILE_SEPARATOR, JVM_DLL);
if(check_file_exist(path))
return path;
sprintf(path, "%s%c%s", java_home_path, FILE_SEPARATOR, JVM_DLL);
if(check_file_exist(path))
return path;
free(path);
return NULL;
}
void deps_resolver_t::setup_probe_config(
const corehost_init_t* init,
const runtime_config_t& config,
const arguments_t& args)
{
if (pal::directory_exists(args.dotnet_extensions))
{
pal::string_t ext_ni = args.dotnet_extensions;
append_path(&ext_ni, get_arch());
if (pal::directory_exists(ext_ni))
{
// Servicing NI probe.
m_probes.push_back(probe_config_t::svc_ni(ext_ni, config.get_patch_roll_fwd(), config.get_prerelease_roll_fwd()));
}
// Servicing normal probe.
m_probes.push_back(probe_config_t::svc(args.dotnet_extensions, config.get_patch_roll_fwd(), config.get_prerelease_roll_fwd()));
}
if (pal::directory_exists(args.dotnet_packages_cache))
{
pal::string_t ni_packages_cache = args.dotnet_packages_cache;
append_path(&ni_packages_cache, get_arch());
if (pal::directory_exists(ni_packages_cache))
{
// Packages cache NI probe
m_probes.push_back(probe_config_t::cache_ni(ni_packages_cache));
}
// Packages cache probe
m_probes.push_back(probe_config_t::cache(args.dotnet_packages_cache));
}
if (pal::directory_exists(m_fx_dir))
{
// FX probe
m_probes.push_back(probe_config_t::fx(m_fx_dir, m_fx_deps.get()));
}
for (const auto& probe : m_additional_probes)
{
// Additional paths
bool patch_roll_fwd = config.get_patch_roll_fwd();
bool prerelease_roll_fwd = config.get_prerelease_roll_fwd();
m_probes.push_back(probe_config_t::additional(probe, patch_roll_fwd, prerelease_roll_fwd));
}
if (trace::is_enabled())
{
trace::verbose(_X("-- Listing probe configurations..."));
for (const auto& pc : m_probes)
{
pc.print();
}
}
}
void deps_resolver_t::setup_probe_config(
const hostpolicy_init_t& init,
const arguments_t& args)
{
if (pal::directory_exists(args.core_servicing))
{
pal::string_t ext_ni = args.core_servicing;
append_path(&ext_ni, get_arch());
if (pal::directory_exists(ext_ni))
{
// Servicing NI probe.
m_probes.push_back(probe_config_t::svc_ni(ext_ni, false, false));
}
// Servicing normal probe.
pal::string_t ext_pkgs = args.core_servicing;
append_path(&ext_pkgs, _X("pkgs"));
m_probes.push_back(probe_config_t::svc(ext_pkgs, false, false));
}
if (pal::directory_exists(args.dotnet_packages_cache))
{
pal::string_t ni_packages_cache = args.dotnet_packages_cache;
append_path(&ni_packages_cache, get_arch());
if (pal::directory_exists(ni_packages_cache))
{
// Packages cache NI probe
m_probes.push_back(probe_config_t::cache_ni(ni_packages_cache));
}
// Packages cache probe
m_probes.push_back(probe_config_t::cache(args.dotnet_packages_cache));
}
if (pal::directory_exists(m_fx_dir))
{
// FX probe
m_probes.push_back(probe_config_t::fx(m_fx_dir, m_fx_deps.get()));
}
for (const auto& probe : m_additional_probes)
{
// Additional paths
m_probes.push_back(probe_config_t::additional(probe));
}
if (trace::is_enabled())
{
trace::verbose(_X("-- Listing probe configurations..."));
for (const auto& pc : m_probes)
{
pc.print();
}
}
}
static AVSValue __cdecl
create_maskedmerge(AVSValue args, void*, IScriptEnvironment* env)
{
enum { BASE, ALT, MASK, MI, BLOCKX, BLOCKY, CHROMA, OPT };
try {
validate(!args[BASE].Defined(), "base clip is not set.");
validate(!args[ALT].Defined(), "alt clip is not set.");
validate(!args[MASK].Defined(), "mask clip is not set.");
PClip base = args[BASE].AsClip();
PClip alt = args[ALT].AsClip();
PClip mask = args[MASK].AsClip();
int mi = args[MI].AsInt(40);
int bx = args[BLOCKX].AsInt(8);
int by = args[BLOCKY].AsInt(8);
bool ch = args[CHROMA].AsBool(true);
bool is_avsplus = env->FunctionExists("SetFilterMTMode");
arch_t arch = get_arch(args[OPT].AsInt(-1), is_avsplus);
return new MaskedMerge(base, alt, mask, mi, bx, by, ch, arch, is_avsplus);
} catch (std::runtime_error& e) {
env->ThrowError("MaskedMerge: %s", e.what());
}
return 0;
}
bool servicing_index_t::find_redirection(
const pal::string_t& package_name,
const pal::string_t& package_version,
const pal::string_t& package_relative,
pal::string_t* redirection)
{
ensure_redirections();
redirection->clear();
if (m_redirections.empty())
{
return false;
}
pal::stringstream_t stream;
stream << package_name << _X("|") << package_version << _X("|") << package_relative;
auto iter = m_redirections.find(stream.str());
if (iter != m_redirections.end())
{
pal::string_t ni_root = m_patch_root;
append_path(&ni_root, get_arch());
// First prefer the architecture specific NI image.
pal::string_t paths[2] = { ni_root, m_patch_root };
for (pal::string_t& full_path : paths)
{
append_path(&full_path, iter->second.c_str());
if (pal::file_exists(full_path))
{
*redirection = full_path;
if (trace::is_enabled())
{
pal::string_t stream_str = stream.str();
trace::verbose(_X("Servicing %s with %s"), stream_str.c_str(), redirection->c_str());
}
return true;
}
trace::verbose(_X("Serviced file %s doesn't exist"), full_path.c_str());
}
}
if (trace::is_enabled())
{
auto stream_str = stream.str();
trace::verbose(_X("Entry %s not serviced or file doesn't exist"), stream_str.c_str());
}
return false;
}
void deps_resolver_t::setup_probe_config(
const arguments_t& args)
{
if (pal::directory_exists(args.core_servicing))
{
pal::string_t ext_ni = args.core_servicing;
append_path(&ext_ni, get_arch());
if (pal::directory_exists(ext_ni))
{
// Servicing NI probe.
m_probes.push_back(probe_config_t::svc_ni(ext_ni));
}
// Servicing normal probe.
pal::string_t ext_pkgs = args.core_servicing;
append_path(&ext_pkgs, _X("pkgs"));
m_probes.push_back(probe_config_t::svc(ext_pkgs));
}
// The published deps directory to be probed: either app or FX directory.
// The probe directory will be available at probe time.
m_probes.push_back(probe_config_t::published_deps_dir());
// The framework locations, starting with highest level framework.
for (int i = 1; i < m_fx_definitions.size(); ++i)
{
if (pal::directory_exists(m_fx_definitions[i]->get_dir()))
{
m_probes.push_back(probe_config_t::fx(m_fx_definitions[i]->get_dir(), &m_fx_definitions[i]->get_deps(), i));
}
}
setup_shared_store_probes(args);
for (const auto& probe : m_additional_probes)
{
// Additional paths
m_probes.push_back(probe_config_t::lookup(probe));
}
if (trace::is_enabled())
{
trace::verbose(_X("-- Listing probe configurations..."));
for (const auto& pc : m_probes)
{
pc.print();
}
}
}
static AVSValue __cdecl
create_iscombed(AVSValue args, void*, ise_t* env)
{
enum { CLIP, CTHRESH, MTHRESH, MI, BLOCKX, BLOCKY, METRIC, OPT };
CombMask* cm = nullptr;
try {
AVSValue cf = env->GetVar("current_frame");
validate(!cf.IsInt(),
"This filter can only be used within ConditionalFilter.");
int n = cf.AsInt();
PClip clip = args[CLIP].AsClip();
int metric = args[METRIC].AsInt(0);
int cth = args[CTHRESH].AsInt(metric == 0 ? 6 : 10);
int mth = args[MTHRESH].AsInt(9);
int mi = args[MI].AsInt(80);
int blockx = args[BLOCKX].AsInt(16);
int blocky = args[BLOCKY].AsInt(16);
bool is_avsplus = env->FunctionExists("SetFilterMTMode");
arch_t arch = get_arch(args[OPT].AsInt(-1), is_avsplus);
validate(mi < 0 || mi > 128, "MI must be between 0 and 128.");
validate(blockx != 8 && blockx != 16 && blockx != 32,
"blockx must be set to 8, 16 or 32.");
validate(blocky != 8 && blocky != 16 && blocky != 32,
"blocky must be set to 8, 16 or 32.");
cm = new CombMask(clip, cth, mth, false, arch, false, metric, is_avsplus);
bool is_combed = (get_check_combed(arch))(
cm->GetFrame(n, env), mi, blockx, blocky, is_avsplus, env);
delete cm;
return AVSValue(is_combed);
} catch (std::runtime_error& e) {
if (cm) delete cm;
env->ThrowError("IsCombed: %s", e.what());
}
return 0;
}
int main(int argc, char *argv[])
{
prepare();
base_info vm_base_info;
vm_base_info.issue = get_dis();
vm_base_info.hostname = get_hostname();
vm_base_info.kernel = get_kernel();
vm_base_info.arch = get_arch();
printf("%d %d\n", vm_base_info.issue, vm_issue);
printf("%s\n", vm_base_info.hostname);
printf("%s\n", vm_base_info.kernel);
printf("%s\n", vm_base_info.arch);
/* TODO: not forget memory free */
}
bool pal::get_local_dotnet_dir(pal::string_t* recv)
{
recv->clear();
pal::string_t dir;
if (!pal::getenv("HOME", &dir))
{
struct passwd* pw = getpwuid(getuid());
if (pw && pw->pw_dir)
{
dir.assign(pw->pw_dir);
}
}
if (dir.empty())
{
return false;
}
append_path(&dir, _X(".dotnet"));
append_path(&dir, get_arch());
recv->assign(dir);
return true;
}
static AVSValue __cdecl
create_combmask(AVSValue args, void* user_data, ise_t* env)
{
enum { CLIP, CTHRESH, MTHRESH, CHROMA, EXPAND, METRIC, OPT };
PClip clip = args[CLIP].AsClip();
int metric = args[METRIC].AsInt(0);
int cth = args[CTHRESH].AsInt(metric == 0 ? 6 : 10);
int mth = args[MTHRESH].AsInt(9);
bool ch = args[CHROMA].AsBool(true);
bool expand = args[EXPAND].AsBool(true);
bool is_avsplus = env->FunctionExists("SetFilterMTMode");
arch_t arch = get_arch(args[OPT].AsInt(-1), is_avsplus);
try{
return new CombMask(clip, cth, mth, ch, arch, expand, metric, is_avsplus);
} catch (std::runtime_error& e) {
env->ThrowError("CombMask: %s", e.what());
}
return 0;
}
SHARED_API int corehost_main(const int argc, const pal::char_t* argv[])
{
if (trace::is_enabled())
{
trace::info(_X("--- Invoked hostpolicy [commit hash: %s] [%s,%s,%s][%s] main = {"),
_STRINGIFY(REPO_COMMIT_HASH),
_STRINGIFY(HOST_POLICY_PKG_NAME),
_STRINGIFY(HOST_POLICY_PKG_VER),
_STRINGIFY(HOST_POLICY_PKG_REL_DIR),
get_arch());
for (int i = 0; i < argc; ++i)
{
trace::info(_X("%s"), argv[i]);
}
trace::info(_X("}"));
trace::info(_X("Deps file: %s"), g_init.deps_file.c_str());
for (const auto& probe : g_init.probe_paths)
{
trace::info(_X("Additional probe dir: %s"), probe.c_str());
}
}
// Take care of arguments
arguments_t args;
if (!parse_arguments(g_init, argc, argv, &args))
{
return StatusCode::LibHostInvalidArgs;
}
if (trace::is_enabled())
{
args.print();
}
return run(args);
}
/* store registers in the guest state (gdbserver_to_valgrind)
or fetch register from the guest state (valgrind_to_gdbserver). */
static
void transfer_register (ThreadId tid, int abs_regno, void * buf,
transfer_direction dir, int size, Bool *mod)
{
ThreadState* tst = VG_(get_ThreadState)(tid);
int set = abs_regno / num_regs;
int regno = abs_regno % num_regs;
*mod = False;
VexGuestARM64State* arm = (VexGuestARM64State*) get_arch (set, tst);
switch (regno) {
// numbers here have to match the order of regs above
// Attention: gdb order does not match valgrind order.
case 0: VG_(transfer) (&arm->guest_X0, buf, dir, size, mod); break;
case 1: VG_(transfer) (&arm->guest_X1, buf, dir, size, mod); break;
case 2: VG_(transfer) (&arm->guest_X2, buf, dir, size, mod); break;
case 3: VG_(transfer) (&arm->guest_X3, buf, dir, size, mod); break;
case 4: VG_(transfer) (&arm->guest_X4, buf, dir, size, mod); break;
case 5: VG_(transfer) (&arm->guest_X5, buf, dir, size, mod); break;
case 6: VG_(transfer) (&arm->guest_X6, buf, dir, size, mod); break;
case 7: VG_(transfer) (&arm->guest_X7, buf, dir, size, mod); break;
case 8: VG_(transfer) (&arm->guest_X8, buf, dir, size, mod); break;
case 9: VG_(transfer) (&arm->guest_X9, buf, dir, size, mod); break;
case 10: VG_(transfer) (&arm->guest_X10, buf, dir, size, mod); break;
case 11: VG_(transfer) (&arm->guest_X11, buf, dir, size, mod); break;
case 12: VG_(transfer) (&arm->guest_X12, buf, dir, size, mod); break;
case 13: VG_(transfer) (&arm->guest_X13, buf, dir, size, mod); break;
case 14: VG_(transfer) (&arm->guest_X14, buf, dir, size, mod); break;
case 15: VG_(transfer) (&arm->guest_X15, buf, dir, size, mod); break;
case 16: VG_(transfer) (&arm->guest_X16, buf, dir, size, mod); break;
case 17: VG_(transfer) (&arm->guest_X17, buf, dir, size, mod); break;
case 18: VG_(transfer) (&arm->guest_X18, buf, dir, size, mod); break;
case 19: VG_(transfer) (&arm->guest_X19, buf, dir, size, mod); break;
case 20: VG_(transfer) (&arm->guest_X20, buf, dir, size, mod); break;
case 21: VG_(transfer) (&arm->guest_X21, buf, dir, size, mod); break;
case 22: VG_(transfer) (&arm->guest_X22, buf, dir, size, mod); break;
case 23: VG_(transfer) (&arm->guest_X23, buf, dir, size, mod); break;
case 24: VG_(transfer) (&arm->guest_X24, buf, dir, size, mod); break;
case 25: VG_(transfer) (&arm->guest_X25, buf, dir, size, mod); break;
case 26: VG_(transfer) (&arm->guest_X26, buf, dir, size, mod); break;
case 27: VG_(transfer) (&arm->guest_X27, buf, dir, size, mod); break;
case 28: VG_(transfer) (&arm->guest_X28, buf, dir, size, mod); break;
case 29: VG_(transfer) (&arm->guest_X29, buf, dir, size, mod); break;
case 30: VG_(transfer) (&arm->guest_X30, buf, dir, size, mod); break;
case 31: VG_(transfer) (&arm->guest_XSP, buf, dir, size, mod); break;
case 32: VG_(transfer) (&arm->guest_PC, buf, dir, size, mod); break;
case 33: *mod = False; // GDBTD cpsr what to do for arm64 ???
case 34: VG_(transfer) (&arm->guest_Q0, buf, dir, size, mod); break;
case 35: VG_(transfer) (&arm->guest_Q1, buf, dir, size, mod); break;
case 36: VG_(transfer) (&arm->guest_Q2, buf, dir, size, mod); break;
case 37: VG_(transfer) (&arm->guest_Q3, buf, dir, size, mod); break;
case 38: VG_(transfer) (&arm->guest_Q4, buf, dir, size, mod); break;
case 39: VG_(transfer) (&arm->guest_Q5, buf, dir, size, mod); break;
case 40: VG_(transfer) (&arm->guest_Q6, buf, dir, size, mod); break;
case 41: VG_(transfer) (&arm->guest_Q7, buf, dir, size, mod); break;
case 42: VG_(transfer) (&arm->guest_Q8, buf, dir, size, mod); break;
case 43: VG_(transfer) (&arm->guest_Q9, buf, dir, size, mod); break;
case 44: VG_(transfer) (&arm->guest_Q10, buf, dir, size, mod); break;
case 45: VG_(transfer) (&arm->guest_Q11, buf, dir, size, mod); break;
case 46: VG_(transfer) (&arm->guest_Q12, buf, dir, size, mod); break;
case 47: VG_(transfer) (&arm->guest_Q13, buf, dir, size, mod); break;
case 48: VG_(transfer) (&arm->guest_Q14, buf, dir, size, mod); break;
case 49: VG_(transfer) (&arm->guest_Q15, buf, dir, size, mod); break;
case 50: VG_(transfer) (&arm->guest_Q16, buf, dir, size, mod); break;
case 51: VG_(transfer) (&arm->guest_Q17, buf, dir, size, mod); break;
case 52: VG_(transfer) (&arm->guest_Q18, buf, dir, size, mod); break;
case 53: VG_(transfer) (&arm->guest_Q19, buf, dir, size, mod); break;
case 54: VG_(transfer) (&arm->guest_Q20, buf, dir, size, mod); break;
case 55: VG_(transfer) (&arm->guest_Q21, buf, dir, size, mod); break;
case 56: VG_(transfer) (&arm->guest_Q22, buf, dir, size, mod); break;
case 57: VG_(transfer) (&arm->guest_Q23, buf, dir, size, mod); break;
case 58: VG_(transfer) (&arm->guest_Q24, buf, dir, size, mod); break;
case 59: VG_(transfer) (&arm->guest_Q25, buf, dir, size, mod); break;
case 60: VG_(transfer) (&arm->guest_Q26, buf, dir, size, mod); break;
case 61: VG_(transfer) (&arm->guest_Q27, buf, dir, size, mod); break;
case 62: VG_(transfer) (&arm->guest_Q28, buf, dir, size, mod); break;
case 63: VG_(transfer) (&arm->guest_Q29, buf, dir, size, mod); break;
case 64: VG_(transfer) (&arm->guest_Q30, buf, dir, size, mod); break;
case 65: VG_(transfer) (&arm->guest_Q31, buf, dir, size, mod); break;
case 66: VG_(transfer) (&arm->guest_FPSR, buf, dir, size, mod); break;
case 67: VG_(transfer) (&arm->guest_FPCR, buf, dir, size, mod); break;
default: vg_assert(0);
}
}
/* store registers in the guest state (gdbserver_to_valgrind)
or fetch register from the guest state (valgrind_to_gdbserver). */
static
void transfer_register (ThreadId tid, int abs_regno, void * buf,
transfer_direction dir, int size, Bool *mod)
{
ThreadState* tst = VG_(get_ThreadState)(tid);
int set = abs_regno / num_regs;
int regno = abs_regno % num_regs;
*mod = False;
VexGuestMIPS64State* mips1 = (VexGuestMIPS64State*) get_arch (set, tst);
switch (regno) {
case 0: VG_(transfer) (&mips1->guest_r0, buf, dir, size, mod); break;
case 1: VG_(transfer) (&mips1->guest_r1, buf, dir, size, mod); break;
case 2: VG_(transfer) (&mips1->guest_r2, buf, dir, size, mod); break;
case 3: VG_(transfer) (&mips1->guest_r3, buf, dir, size, mod); break;
case 4: VG_(transfer) (&mips1->guest_r4, buf, dir, size, mod); break;
case 5: VG_(transfer) (&mips1->guest_r5, buf, dir, size, mod); break;
case 6: VG_(transfer) (&mips1->guest_r6, buf, dir, size, mod); break;
case 7: VG_(transfer) (&mips1->guest_r7, buf, dir, size, mod); break;
case 8: VG_(transfer) (&mips1->guest_r8, buf, dir, size, mod); break;
case 9: VG_(transfer) (&mips1->guest_r9, buf, dir, size, mod); break;
case 10: VG_(transfer) (&mips1->guest_r10, buf, dir, size, mod); break;
case 11: VG_(transfer) (&mips1->guest_r11, buf, dir, size, mod); break;
case 12: VG_(transfer) (&mips1->guest_r12, buf, dir, size, mod); break;
case 13: VG_(transfer) (&mips1->guest_r13, buf, dir, size, mod); break;
case 14: VG_(transfer) (&mips1->guest_r14, buf, dir, size, mod); break;
case 15: VG_(transfer) (&mips1->guest_r15, buf, dir, size, mod); break;
case 16: VG_(transfer) (&mips1->guest_r16, buf, dir, size, mod); break;
case 17: VG_(transfer) (&mips1->guest_r17, buf, dir, size, mod); break;
case 18: VG_(transfer) (&mips1->guest_r18, buf, dir, size, mod); break;
case 19: VG_(transfer) (&mips1->guest_r19, buf, dir, size, mod); break;
case 20: VG_(transfer) (&mips1->guest_r20, buf, dir, size, mod); break;
case 21: VG_(transfer) (&mips1->guest_r21, buf, dir, size, mod); break;
case 22: VG_(transfer) (&mips1->guest_r22, buf, dir, size, mod); break;
case 23: VG_(transfer) (&mips1->guest_r23, buf, dir, size, mod); break;
case 24: VG_(transfer) (&mips1->guest_r24, buf, dir, size, mod); break;
case 25: VG_(transfer) (&mips1->guest_r25, buf, dir, size, mod); break;
case 26: VG_(transfer) (&mips1->guest_r26, buf, dir, size, mod); break;
case 27: VG_(transfer) (&mips1->guest_r27, buf, dir, size, mod); break;
case 28: VG_(transfer) (&mips1->guest_r28, buf, dir, size, mod); break;
case 29: VG_(transfer) (&mips1->guest_r29, buf, dir, size, mod); break;
case 30: VG_(transfer) (&mips1->guest_r30, buf, dir, size, mod); break;
case 31: VG_(transfer) (&mips1->guest_r31, buf, dir, size, mod); break;
case 32: *mod = False; break; // GDBTD???? VEX { "status", 1024, 64 }
case 33: VG_(transfer) (&mips1->guest_LO, buf, dir, size, mod); break;
case 34: VG_(transfer) (&mips1->guest_HI, buf, dir, size, mod); break;
case 35: *mod = False; break; // GDBTD???? VEX { "badvaddr", 1120, 64 },
case 36: *mod = False; break; // GDBTD???? VEX { "cause", 1152, 64 },
case 37: VG_(transfer) (&mips1->guest_PC, buf, dir, size, mod); break;
case 38: VG_(transfer) (&mips1->guest_f0, buf, dir, size, mod); break;
case 39: VG_(transfer) (&mips1->guest_f1, buf, dir, size, mod); break;
case 40: VG_(transfer) (&mips1->guest_f2, buf, dir, size, mod); break;
case 41: VG_(transfer) (&mips1->guest_f3, buf, dir, size, mod); break;
case 42: VG_(transfer) (&mips1->guest_f4, buf, dir, size, mod); break;
case 43: VG_(transfer) (&mips1->guest_f5, buf, dir, size, mod); break;
case 44: VG_(transfer) (&mips1->guest_f6, buf, dir, size, mod); break;
case 45: VG_(transfer) (&mips1->guest_f7, buf, dir, size, mod); break;
case 46: VG_(transfer) (&mips1->guest_f8, buf, dir, size, mod); break;
case 47: VG_(transfer) (&mips1->guest_f9, buf, dir, size, mod); break;
case 48: VG_(transfer) (&mips1->guest_f10, buf, dir, size, mod); break;
case 49: VG_(transfer) (&mips1->guest_f11, buf, dir, size, mod); break;
case 50: VG_(transfer) (&mips1->guest_f12, buf, dir, size, mod); break;
case 51: VG_(transfer) (&mips1->guest_f13, buf, dir, size, mod); break;
case 52: VG_(transfer) (&mips1->guest_f14, buf, dir, size, mod); break;
case 53: VG_(transfer) (&mips1->guest_f15, buf, dir, size, mod); break;
case 54: VG_(transfer) (&mips1->guest_f16, buf, dir, size, mod); break;
case 55: VG_(transfer) (&mips1->guest_f17, buf, dir, size, mod); break;
case 56: VG_(transfer) (&mips1->guest_f18, buf, dir, size, mod); break;
case 57: VG_(transfer) (&mips1->guest_f19, buf, dir, size, mod); break;
case 58: VG_(transfer) (&mips1->guest_f20, buf, dir, size, mod); break;
case 59: VG_(transfer) (&mips1->guest_f21, buf, dir, size, mod); break;
case 60: VG_(transfer) (&mips1->guest_f22, buf, dir, size, mod); break;
case 61: VG_(transfer) (&mips1->guest_f23, buf, dir, size, mod); break;
case 62: VG_(transfer) (&mips1->guest_f24, buf, dir, size, mod); break;
case 63: VG_(transfer) (&mips1->guest_f25, buf, dir, size, mod); break;
case 64: VG_(transfer) (&mips1->guest_f26, buf, dir, size, mod); break;
case 65: VG_(transfer) (&mips1->guest_f27, buf, dir, size, mod); break;
case 66: VG_(transfer) (&mips1->guest_f28, buf, dir, size, mod); break;
case 67: VG_(transfer) (&mips1->guest_f29, buf, dir, size, mod); break;
case 68: VG_(transfer) (&mips1->guest_f30, buf, dir, size, mod); break;
case 69: VG_(transfer) (&mips1->guest_f31, buf, dir, size, mod); break;
case 70: VG_(transfer) (&mips1->guest_FCSR, buf, dir, size, mod); break;
case 71: VG_(transfer) (&mips1->guest_FIR, buf, dir, size, mod); break;
case 72: *mod = False; break; // GDBTD???? VEX{ "restart", 2304, 64 },
default: VG_(printf)("regno: %d\n", regno); vg_assert(0);
}
}
bool pal::get_dotnet_self_registered_dir(pal::string_t* recv)
{
#if !defined(_TARGET_AMD64_) && !defined(_TARGET_X86_)
// Self-registered SDK installation directory is only supported for x64 and x86 architectures.
return false;
#else
recv->clear();
// ***Used only for testing***
pal::string_t environmentOverride;
if (pal::getenv(_X("_DOTNET_TEST_GLOBALLY_REGISTERED_PATH"), &environmentOverride))
{
recv->assign(environmentOverride);
return true;
}
// ***************************
DWORD size = 0;
HKEY hkeyHive = HKEY_LOCAL_MACHINE;
// The registry search occurs in the 32-bit registry in all cases.
pal::string_t dotnet_key_path = pal::string_t(_X("SOFTWARE\\dotnet"));
pal::string_t environmentRegistryPathOverride;
if (pal::getenv(_X("_DOTNET_TEST_REGISTRY_PATH"), &environmentRegistryPathOverride))
{
pal::string_t hkcuPrefix = _X("HKEY_CURRENT_USER\\");
if (environmentRegistryPathOverride.substr(0, hkcuPrefix.length()) == hkcuPrefix)
{
hkeyHive = HKEY_CURRENT_USER;
environmentRegistryPathOverride = environmentRegistryPathOverride.substr(hkcuPrefix.length());
}
dotnet_key_path = environmentRegistryPathOverride;
}
pal::string_t sub_key = dotnet_key_path + pal::string_t(_X("\\Setup\\InstalledVersions\\")) + get_arch();
pal::char_t* value = _X("InstallLocation");
// Must use RegOpenKeyEx to be able to specify KEY_WOW64_32KEY to access the 32-bit registry in all cases.
// The RegGetValue has this option available only on Win10.
HKEY hkey = NULL;
LSTATUS result = ::RegOpenKeyExW(hkeyHive, sub_key.c_str(), 0, KEY_READ | KEY_WOW64_32KEY, &hkey);
if (result != ERROR_SUCCESS)
{
trace::verbose(_X("Can't open the SDK installed location registry key, result: 0x%X"), result);
return false;
}
// Determine the size of the buffer
result = ::RegGetValueW(hkey, nullptr, value, RRF_RT_REG_SZ, nullptr, nullptr, &size);
if (result != ERROR_SUCCESS || size == 0)
{
trace::verbose(_X("Can't get the size of the SDK location registry value or it's empty, result: 0x%X"), result);
::RegCloseKey(hkey);
return false;
}
// Get the key's value
std::vector<pal::char_t> buffer(size/sizeof(pal::char_t));
result = ::RegGetValueW(hkey, nullptr, value, RRF_RT_REG_SZ, nullptr, &buffer[0], &size);
if (result != ERROR_SUCCESS)
{
trace::verbose(_X("Can't get the value of the SDK location registry value, result: 0x%X"), result);
::RegCloseKey(hkey);
return false;
}
recv->assign(buffer.data());
::RegCloseKey(hkey);
return true;
#endif
}
/* store registers in the guest state (gdbserver_to_valgrind)
or fetch register from the guest state (valgrind_to_gdbserver). */
static
void transfer_register ( ThreadId tid, int abs_regno, void * buf,
transfer_direction dir, int size, Bool *mod )
{
ThreadState* tst = VG_(get_ThreadState)(tid);
int set = abs_regno / num_regs;
int regno = abs_regno % num_regs;
*mod = False;
VexGuestTILEGXState* tilegx = (VexGuestTILEGXState*) get_arch (set, tst);
switch (regno) {
case 0: VG_(transfer) (&tilegx->guest_r0, buf, dir, size, mod); break;
case 1: VG_(transfer) (&tilegx->guest_r1, buf, dir, size, mod); break;
case 2: VG_(transfer) (&tilegx->guest_r2, buf, dir, size, mod); break;
case 3: VG_(transfer) (&tilegx->guest_r3, buf, dir, size, mod); break;
case 4: VG_(transfer) (&tilegx->guest_r4, buf, dir, size, mod); break;
case 5: VG_(transfer) (&tilegx->guest_r5, buf, dir, size, mod); break;
case 6: VG_(transfer) (&tilegx->guest_r6, buf, dir, size, mod); break;
case 7: VG_(transfer) (&tilegx->guest_r7, buf, dir, size, mod); break;
case 8: VG_(transfer) (&tilegx->guest_r8, buf, dir, size, mod); break;
case 9: VG_(transfer) (&tilegx->guest_r9, buf, dir, size, mod); break;
case 10: VG_(transfer) (&tilegx->guest_r10, buf, dir, size, mod); break;
case 11: VG_(transfer) (&tilegx->guest_r11, buf, dir, size, mod); break;
case 12: VG_(transfer) (&tilegx->guest_r12, buf, dir, size, mod); break;
case 13: VG_(transfer) (&tilegx->guest_r13, buf, dir, size, mod); break;
case 14: VG_(transfer) (&tilegx->guest_r14, buf, dir, size, mod); break;
case 15: VG_(transfer) (&tilegx->guest_r15, buf, dir, size, mod); break;
case 16: VG_(transfer) (&tilegx->guest_r16, buf, dir, size, mod); break;
case 17: VG_(transfer) (&tilegx->guest_r17, buf, dir, size, mod); break;
case 18: VG_(transfer) (&tilegx->guest_r18, buf, dir, size, mod); break;
case 19: VG_(transfer) (&tilegx->guest_r19, buf, dir, size, mod); break;
case 20: VG_(transfer) (&tilegx->guest_r20, buf, dir, size, mod); break;
case 21: VG_(transfer) (&tilegx->guest_r21, buf, dir, size, mod); break;
case 22: VG_(transfer) (&tilegx->guest_r22, buf, dir, size, mod); break;
case 23: VG_(transfer) (&tilegx->guest_r23, buf, dir, size, mod); break;
case 24: VG_(transfer) (&tilegx->guest_r24, buf, dir, size, mod); break;
case 25: VG_(transfer) (&tilegx->guest_r25, buf, dir, size, mod); break;
case 26: VG_(transfer) (&tilegx->guest_r26, buf, dir, size, mod); break;
case 27: VG_(transfer) (&tilegx->guest_r27, buf, dir, size, mod); break;
case 28: VG_(transfer) (&tilegx->guest_r28, buf, dir, size, mod); break;
case 29: VG_(transfer) (&tilegx->guest_r29, buf, dir, size, mod); break;
case 30: VG_(transfer) (&tilegx->guest_r30, buf, dir, size, mod); break;
case 31: VG_(transfer) (&tilegx->guest_r31, buf, dir, size, mod); break;
case 32: VG_(transfer) (&tilegx->guest_r32, buf, dir, size, mod); break;
case 33: VG_(transfer) (&tilegx->guest_r33, buf, dir, size, mod); break;
case 34: VG_(transfer) (&tilegx->guest_r34, buf, dir, size, mod); break;
case 35: VG_(transfer) (&tilegx->guest_r35, buf, dir, size, mod); break;
case 36: VG_(transfer) (&tilegx->guest_r36, buf, dir, size, mod); break;
case 37: VG_(transfer) (&tilegx->guest_r37, buf, dir, size, mod); break;
case 38: VG_(transfer) (&tilegx->guest_r38, buf, dir, size, mod); break;
case 39: VG_(transfer) (&tilegx->guest_r39, buf, dir, size, mod); break;
case 40: VG_(transfer) (&tilegx->guest_r40, buf, dir, size, mod); break;
case 41: VG_(transfer) (&tilegx->guest_r41, buf, dir, size, mod); break;
case 42: VG_(transfer) (&tilegx->guest_r42, buf, dir, size, mod); break;
case 43: VG_(transfer) (&tilegx->guest_r43, buf, dir, size, mod); break;
case 44: VG_(transfer) (&tilegx->guest_r44, buf, dir, size, mod); break;
case 45: VG_(transfer) (&tilegx->guest_r45, buf, dir, size, mod); break;
case 46: VG_(transfer) (&tilegx->guest_r46, buf, dir, size, mod); break;
case 47: VG_(transfer) (&tilegx->guest_r47, buf, dir, size, mod); break;
case 48: VG_(transfer) (&tilegx->guest_r48, buf, dir, size, mod); break;
case 49: VG_(transfer) (&tilegx->guest_r49, buf, dir, size, mod); break;
case 50: VG_(transfer) (&tilegx->guest_r50, buf, dir, size, mod); break;
case 51: VG_(transfer) (&tilegx->guest_r51, buf, dir, size, mod); break;
case 52: VG_(transfer) (&tilegx->guest_r52, buf, dir, size, mod); break;
case 53: VG_(transfer) (&tilegx->guest_r53, buf, dir, size, mod); break;
case 54: VG_(transfer) (&tilegx->guest_r54, buf, dir, size, mod); break;
case 55: VG_(transfer) (&tilegx->guest_r55, buf, dir, size, mod); break;
case 56: VG_(transfer) (&tilegx->guest_r56, buf, dir, size, mod); break;
case 57: VG_(transfer) (&tilegx->guest_r57, buf, dir, size, mod); break;
case 58: VG_(transfer) (&tilegx->guest_r58, buf, dir, size, mod); break;
case 59: VG_(transfer) (&tilegx->guest_r59, buf, dir, size, mod); break;
case 60: VG_(transfer) (&tilegx->guest_r60, buf, dir, size, mod); break;
case 61: VG_(transfer) (&tilegx->guest_r61, buf, dir, size, mod); break;
case 62: VG_(transfer) (&tilegx->guest_r62, buf, dir, size, mod); break;
case 63: VG_(transfer) (&tilegx->guest_r63, buf, dir, size, mod); break;
case 64: VG_(transfer) (&tilegx->guest_pc, buf, dir, size, mod); break;
default: VG_(printf)("regno: %d\n", regno); vg_assert(0);
}
}
/* store registers in the guest state (gdbserver_to_valgrind)
or fetch register from the guest state (valgrind_to_gdbserver). */
static
void transfer_register (ThreadId tid, int abs_regno, void * buf,
transfer_direction dir, int size, Bool *mod)
{
ThreadState* tst = VG_(get_ThreadState)(tid);
int set = abs_regno / num_regs;
int regno = abs_regno % num_regs;
*mod = False;
VexGuestARMState* arm = (VexGuestARMState*) get_arch (set, tst);
switch (regno) {
// numbers here have to match the order of regs above
// Attention: gdb order does not match valgrind order.
case 0:
VG_(transfer) (&arm->guest_R0, buf, dir, size, mod);
break;
case 1:
VG_(transfer) (&arm->guest_R1, buf, dir, size, mod);
break;
case 2:
VG_(transfer) (&arm->guest_R2, buf, dir, size, mod);
break;
case 3:
VG_(transfer) (&arm->guest_R3, buf, dir, size, mod);
break;
case 4:
VG_(transfer) (&arm->guest_R4, buf, dir, size, mod);
break;
case 5:
VG_(transfer) (&arm->guest_R5, buf, dir, size, mod);
break;
case 6:
VG_(transfer) (&arm->guest_R6, buf, dir, size, mod);
break;
case 7:
VG_(transfer) (&arm->guest_R7, buf, dir, size, mod);
break;
case 8:
VG_(transfer) (&arm->guest_R8, buf, dir, size, mod);
break;
case 9:
VG_(transfer) (&arm->guest_R9, buf, dir, size, mod);
break;
case 10:
VG_(transfer) (&arm->guest_R10, buf, dir, size, mod);
break;
case 11:
VG_(transfer) (&arm->guest_R11, buf, dir, size, mod);
break;
case 12:
VG_(transfer) (&arm->guest_R12, buf, dir, size, mod);
break;
case 13:
VG_(transfer) (&arm->guest_R13, buf, dir, size, mod);
break;
case 14:
VG_(transfer) (&arm->guest_R14, buf, dir, size, mod);
break;
case 15: {
VG_(transfer) (&arm->guest_R15T, buf, dir, size, mod);
if (dir == gdbserver_to_valgrind && *mod) {
// If gdb is changing the PC, we have to set the thumb bit
// if needed.
arm->guest_R15T = thumb_pc(arm->guest_R15T);
}
break;
}
case 16:
case 17:
case 18:
case 19:
case 20: /* 9 "empty registers". See struct reg regs above. */
case 21:
case 22:
case 23:
case 24:
*mod = False;
break;
case 25: {
UInt cpsr = LibVEX_GuestARM_get_cpsr (arm);
if (dir == valgrind_to_gdbserver) {
VG_(transfer) (&cpsr, buf, dir, size, mod);
} else {
# if 0
UInt newcpsr;
VG_(transfer) (&newcpsr, buf, dir, size, mod);
*mod = newcpsr != cpsr;
// GDBTD ???? see FIXME in guest_arm_helpers.c
LibVEX_GuestARM_put_flags (newcpsr, arm);
# else
*mod = False;
# endif
}
break;
}
case 26:
VG_(transfer) (&arm->guest_D0, buf, dir, size, mod);
break;
case 27:
VG_(transfer) (&arm->guest_D1, buf, dir, size, mod);
break;
case 28:
VG_(transfer) (&arm->guest_D2, buf, dir, size, mod);
break;
case 29:
VG_(transfer) (&arm->guest_D3, buf, dir, size, mod);
break;
case 30:
VG_(transfer) (&arm->guest_D4, buf, dir, size, mod);
break;
case 31:
VG_(transfer) (&arm->guest_D5, buf, dir, size, mod);
break;
case 32:
VG_(transfer) (&arm->guest_D6, buf, dir, size, mod);
break;
case 33:
VG_(transfer) (&arm->guest_D7, buf, dir, size, mod);
break;
case 34:
VG_(transfer) (&arm->guest_D8, buf, dir, size, mod);
break;
case 35:
VG_(transfer) (&arm->guest_D9, buf, dir, size, mod);
break;
case 36:
VG_(transfer) (&arm->guest_D10, buf, dir, size, mod);
break;
case 37:
VG_(transfer) (&arm->guest_D11, buf, dir, size, mod);
break;
case 38:
VG_(transfer) (&arm->guest_D12, buf, dir, size, mod);
break;
case 39:
VG_(transfer) (&arm->guest_D13, buf, dir, size, mod);
break;
case 40:
VG_(transfer) (&arm->guest_D14, buf, dir, size, mod);
break;
case 41:
VG_(transfer) (&arm->guest_D15, buf, dir, size, mod);
break;
case 42:
VG_(transfer) (&arm->guest_D16, buf, dir, size, mod);
break;
case 43:
VG_(transfer) (&arm->guest_D17, buf, dir, size, mod);
break;
case 44:
VG_(transfer) (&arm->guest_D18, buf, dir, size, mod);
break;
case 45:
VG_(transfer) (&arm->guest_D19, buf, dir, size, mod);
break;
case 46:
VG_(transfer) (&arm->guest_D20, buf, dir, size, mod);
break;
case 47:
VG_(transfer) (&arm->guest_D21, buf, dir, size, mod);
break;
case 48:
VG_(transfer) (&arm->guest_D22, buf, dir, size, mod);
break;
case 49:
VG_(transfer) (&arm->guest_D23, buf, dir, size, mod);
break;
case 50:
VG_(transfer) (&arm->guest_D24, buf, dir, size, mod);
break;
case 51:
VG_(transfer) (&arm->guest_D25, buf, dir, size, mod);
break;
case 52:
VG_(transfer) (&arm->guest_D26, buf, dir, size, mod);
break;
case 53:
VG_(transfer) (&arm->guest_D27, buf, dir, size, mod);
break;
case 54:
VG_(transfer) (&arm->guest_D28, buf, dir, size, mod);
break;
case 55:
VG_(transfer) (&arm->guest_D29, buf, dir, size, mod);
break;
case 56:
VG_(transfer) (&arm->guest_D30, buf, dir, size, mod);
break;
case 57:
VG_(transfer) (&arm->guest_D31, buf, dir, size, mod);
break;
case 58:
VG_(transfer) (&arm->guest_FPSCR, buf, dir, size, mod);
break;
default:
vg_assert(0);
}
}
/* store registers in the guest state (gdbserver_to_valgrind)
or fetch register from the guest state (valgrind_to_gdbserver). */
static
void transfer_register (ThreadId tid, int abs_regno, void * buf,
transfer_direction dir, int size, Bool *mod)
{
ThreadState* tst = VG_(get_ThreadState)(tid);
int set = abs_regno / num_regs;
int regno = abs_regno % num_regs;
*mod = False;
VexGuestX86State* x86 = (VexGuestX86State*) get_arch (set, tst);
switch (regno) {
// numbers here have to match the order of regs above
// Attention: gdb order does not match valgrind order.
case 0: VG_(transfer) (&x86->guest_EAX, buf, dir, size, mod); break;
case 1: VG_(transfer) (&x86->guest_ECX, buf, dir, size, mod); break;
case 2: VG_(transfer) (&x86->guest_EDX, buf, dir, size, mod); break;
case 3: VG_(transfer) (&x86->guest_EBX, buf, dir, size, mod); break;
case 4: VG_(transfer) (&x86->guest_ESP, buf, dir, size, mod); break;
case 5: VG_(transfer) (&x86->guest_EBP, buf, dir, size, mod); break;
case 6: VG_(transfer) (&x86->guest_ESI, buf, dir, size, mod); break;
case 7: VG_(transfer) (&x86->guest_EDI, buf, dir, size, mod); break;
case 8: VG_(transfer) (&x86->guest_EIP, buf, dir, size, mod); break;
case 9:
if (dir == valgrind_to_gdbserver) {
UInt eflags;
/* we can only retrieve the real flags (set 0)
retrieving shadow flags is not ok */
if (set == 0)
eflags = LibVEX_GuestX86_get_eflags (x86);
else
eflags = 0;
VG_(transfer) (&eflags, buf, dir, size, mod); break;
} else {
*mod = False; //GDBTD? how do we store eflags in libvex_guest_x86.h ???
}
break;
case 10: VG_(transfer) (&x86->guest_CS, buf, dir, size, mod); break;
case 11: VG_(transfer) (&x86->guest_SS, buf, dir, size, mod); break;
case 12: VG_(transfer) (&x86->guest_DS, buf, dir, size, mod); break;
case 13: VG_(transfer) (&x86->guest_ES, buf, dir, size, mod); break;
case 14: VG_(transfer) (&x86->guest_FS, buf, dir, size, mod); break;
case 15: VG_(transfer) (&x86->guest_GS, buf, dir, size, mod); break;
case 16:
case 17:
case 18:
case 19: /* register 16 to 23 are float registers 80 bits but 64 bits in valgrind */
case 20:
case 21:
case 22:
case 23: {
if (dir == valgrind_to_gdbserver) {
UChar fpreg80[10];
convert_f64le_to_f80le ((UChar *)&x86->guest_FPREG[regno-16],
fpreg80);
VG_(transfer) (&fpreg80, buf, dir, sizeof(fpreg80), mod);
} else {
ULong fpreg64;
convert_f80le_to_f64le (buf, (UChar *)&fpreg64);
VG_(transfer) (&x86->guest_FPREG[regno-16], &fpreg64,
dir, sizeof(fpreg64), mod);
}
break;
}
case 24:
if (dir == valgrind_to_gdbserver) {
// vex only models the rounding bits (see libvex_guest_x86.h)
UWord value = 0x037f;
value |= x86->guest_FPROUND << 10;
VG_(transfer)(&value, buf, dir, size, mod);
} else {
*mod = False; // GDBTD???? VEX { "fctrl", 1152, 32 },
}
break;
case 25:
if (dir == valgrind_to_gdbserver) {
UWord value = x86->guest_FC3210;
value |= (x86->guest_FTOP & 7) << 11;
VG_(transfer)(&value, buf, dir, size, mod);
} else {
*mod = False; // GDBTD???? VEX { "fstat", 1184, 32 },
}
break;
case 26:
if (dir == valgrind_to_gdbserver) {
// vex doesn't model these precisely
UWord value =
((x86->guest_FPTAG[0] ? 0 : 3) << 0) |
((x86->guest_FPTAG[1] ? 0 : 3) << 2) |
((x86->guest_FPTAG[2] ? 0 : 3) << 4) |
((x86->guest_FPTAG[3] ? 0 : 3) << 6) |
((x86->guest_FPTAG[4] ? 0 : 3) << 8) |
((x86->guest_FPTAG[5] ? 0 : 3) << 10) |
((x86->guest_FPTAG[6] ? 0 : 3) << 12) |
((x86->guest_FPTAG[7] ? 0 : 3) << 14);
VG_(transfer)(&value, buf, dir, size, mod);
} else {
*mod = False; // GDBTD???? VEX { "ftag", 1216, 32 },
}
break;
case 27: *mod = False; break; // GDBTD???? VEX { "fiseg", 1248, 32 },
case 28: *mod = False; break; // GDBTD???? VEX { "fioff", 1280, 32 },
case 29: *mod = False; break; // GDBTD???? VEX { "foseg", 1312, 32 },
case 30: *mod = False; break; // GDBTD???? VEX { "fooff", 1344, 32 },
case 31: *mod = False; break; // GDBTD???? VEX { "fop", 1376, 32 },
case 32: VG_(transfer) (&x86->guest_XMM0, buf, dir, size, mod); break;
case 33: VG_(transfer) (&x86->guest_XMM1, buf, dir, size, mod); break;
case 34: VG_(transfer) (&x86->guest_XMM2, buf, dir, size, mod); break;
case 35: VG_(transfer) (&x86->guest_XMM3, buf, dir, size, mod); break;
case 36: VG_(transfer) (&x86->guest_XMM4, buf, dir, size, mod); break;
case 37: VG_(transfer) (&x86->guest_XMM5, buf, dir, size, mod); break;
case 38: VG_(transfer) (&x86->guest_XMM6, buf, dir, size, mod); break;
case 39: VG_(transfer) (&x86->guest_XMM7, buf, dir, size, mod); break;
case 40:
if (dir == valgrind_to_gdbserver) {
// vex only models the rounding bits (see libvex_guest_x86.h)
UWord value = 0x1f80;
value |= x86->guest_SSEROUND << 13;
VG_(transfer)(&value, buf, dir, size, mod);
} else {
*mod = False; // GDBTD???? VEX { "mxcsr", 2432, 32 },
}
break;
case 41: *mod = False; break; // GDBTD???? VEX { "orig_eax", 2464, 32 },
default: vg_assert(0);
}
}
static
void transfer_register (ThreadId tid, int abs_regno, void * buf,
transfer_direction dir, int size, Bool *mod)
{
ThreadState* tst = VG_(get_ThreadState)(tid);
int set = abs_regno / num_regs;
int regno = abs_regno % num_regs;
*mod = False;
VexGuestARMState* arm = (VexGuestARMState*) get_arch (set, tst);
switch (regno) {
case 0: VG_(transfer) (&arm->guest_R0, buf, dir, size, mod); break;
case 1: VG_(transfer) (&arm->guest_R1, buf, dir, size, mod); break;
case 2: VG_(transfer) (&arm->guest_R2, buf, dir, size, mod); break;
case 3: VG_(transfer) (&arm->guest_R3, buf, dir, size, mod); break;
case 4: VG_(transfer) (&arm->guest_R4, buf, dir, size, mod); break;
case 5: VG_(transfer) (&arm->guest_R5, buf, dir, size, mod); break;
case 6: VG_(transfer) (&arm->guest_R6, buf, dir, size, mod); break;
case 7: VG_(transfer) (&arm->guest_R7, buf, dir, size, mod); break;
case 8: VG_(transfer) (&arm->guest_R8, buf, dir, size, mod); break;
case 9: VG_(transfer) (&arm->guest_R9, buf, dir, size, mod); break;
case 10: VG_(transfer) (&arm->guest_R10, buf, dir, size, mod); break;
case 11: VG_(transfer) (&arm->guest_R11, buf, dir, size, mod); break;
case 12: VG_(transfer) (&arm->guest_R12, buf, dir, size, mod); break;
case 13: VG_(transfer) (&arm->guest_R13, buf, dir, size, mod); break;
case 14: VG_(transfer) (&arm->guest_R14, buf, dir, size, mod); break;
case 15: {
VG_(transfer) (&arm->guest_R15T, buf, dir, size, mod);
if (dir == gdbserver_to_valgrind && *mod) {
arm->guest_R15T = thumb_pc(arm->guest_R15T);
}
break;
}
case 16:
case 17:
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
case 24: *mod = False; break;
case 25: {
UInt cpsr = LibVEX_GuestARM_get_cpsr (arm);
if (dir == valgrind_to_gdbserver) {
VG_(transfer) (&cpsr, buf, dir, size, mod);
} else {
# if 0
UInt newcpsr;
VG_(transfer) (&newcpsr, buf, dir, size, mod);
*mod = newcpsr != cpsr;
LibVEX_GuestARM_put_flags (newcpsr, arm);
# else
*mod = False;
# endif
}
break;
}
case 26: VG_(transfer) (&arm->guest_D0, buf, dir, size, mod); break;
case 27: VG_(transfer) (&arm->guest_D1, buf, dir, size, mod); break;
case 28: VG_(transfer) (&arm->guest_D2, buf, dir, size, mod); break;
case 29: VG_(transfer) (&arm->guest_D3, buf, dir, size, mod); break;
case 30: VG_(transfer) (&arm->guest_D4, buf, dir, size, mod); break;
case 31: VG_(transfer) (&arm->guest_D5, buf, dir, size, mod); break;
case 32: VG_(transfer) (&arm->guest_D6, buf, dir, size, mod); break;
case 33: VG_(transfer) (&arm->guest_D7, buf, dir, size, mod); break;
case 34: VG_(transfer) (&arm->guest_D8, buf, dir, size, mod); break;
case 35: VG_(transfer) (&arm->guest_D9, buf, dir, size, mod); break;
case 36: VG_(transfer) (&arm->guest_D10, buf, dir, size, mod); break;
case 37: VG_(transfer) (&arm->guest_D11, buf, dir, size, mod); break;
case 38: VG_(transfer) (&arm->guest_D12, buf, dir, size, mod); break;
case 39: VG_(transfer) (&arm->guest_D13, buf, dir, size, mod); break;
case 40: VG_(transfer) (&arm->guest_D14, buf, dir, size, mod); break;
case 41: VG_(transfer) (&arm->guest_D15, buf, dir, size, mod); break;
case 42: VG_(transfer) (&arm->guest_D16, buf, dir, size, mod); break;
case 43: VG_(transfer) (&arm->guest_D17, buf, dir, size, mod); break;
case 44: VG_(transfer) (&arm->guest_D18, buf, dir, size, mod); break;
case 45: VG_(transfer) (&arm->guest_D19, buf, dir, size, mod); break;
case 46: VG_(transfer) (&arm->guest_D20, buf, dir, size, mod); break;
case 47: VG_(transfer) (&arm->guest_D21, buf, dir, size, mod); break;
case 48: VG_(transfer) (&arm->guest_D22, buf, dir, size, mod); break;
case 49: VG_(transfer) (&arm->guest_D23, buf, dir, size, mod); break;
case 50: VG_(transfer) (&arm->guest_D24, buf, dir, size, mod); break;
case 51: VG_(transfer) (&arm->guest_D25, buf, dir, size, mod); break;
case 52: VG_(transfer) (&arm->guest_D26, buf, dir, size, mod); break;
case 53: VG_(transfer) (&arm->guest_D27, buf, dir, size, mod); break;
case 54: VG_(transfer) (&arm->guest_D28, buf, dir, size, mod); break;
case 55: VG_(transfer) (&arm->guest_D29, buf, dir, size, mod); break;
case 56: VG_(transfer) (&arm->guest_D30, buf, dir, size, mod); break;
case 57: VG_(transfer) (&arm->guest_D31, buf, dir, size, mod); break;
case 58: VG_(transfer) (&arm->guest_FPSCR, buf, dir, size, mod); break;
default: vg_assert(0);
}
}
int main(int argc, char **argv)
{
int ifd;
uint32_t checksum;
uint32_t addr;
uint32_t ep;
struct stat sbuf;
unsigned char *ptr;
char *name = "";
cmdname = *argv;
addr = ep = 0;
while (--argc > 0 && **++argv == '-')
{
while (*++*argv)
{
switch (**argv)
{
case 'l':
lflag = 1;
break;
case 'A':
if ((--argc <= 0) || (opt_arch = get_arch(*++argv)) < 0)
usage();
goto NXTARG;
case 'C':
if ((--argc <= 0) || (opt_comp = get_comp(*++argv)) < 0)
usage();
goto NXTARG;
case 'O':
if ((--argc <= 0) || (opt_os = get_os(*++argv)) < 0)
usage();
goto NXTARG;
case 'T':
if ((--argc <= 0) || (opt_type = get_type(*++argv)) < 0)
usage();
goto NXTARG;
case 'a':
if (--argc <= 0)
usage();
addr = strtoul(*++argv, (char **)&ptr, 16);
if (*ptr)
{
fprintf(stderr,
"%s: invalid load address %s\n",
cmdname, *argv);
exit(EXIT_FAILURE);
}
goto NXTARG;
case 'd':
if (--argc <= 0)
usage();
datafile = *++argv;
dflag = 1;
goto NXTARG;
case 'e':
if (--argc <= 0)
usage();
ep = strtoul(*++argv, (char **)&ptr, 16);
if (*ptr)
{
fprintf(stderr,
"%s: invalid entry point %s\n",
cmdname, *argv);
exit(EXIT_FAILURE);
}
eflag = 1;
goto NXTARG;
case 'n':
if (--argc <= 0)
usage();
name = *++argv;
goto NXTARG;
case 'v':
vflag++;
break;
case 'x':
xflag++;
break;
default:
usage();
}
}
NXTARG:
;
}
if ((argc != 1) || ((lflag ^ dflag) == 0))
usage();
if (!eflag)
{
ep = addr;
/* If XIP, entry point must be after the U-Boot header */
if (xflag)
ep += sizeof(image_header_t);
}
/*
* If XIP, ensure the entry point is equal to the load address plus
* the size of the U-Boot header.
*/
if (xflag)
{
if (ep != addr + sizeof(image_header_t))
{
fprintf(stderr,
"%s: For XIP, the entry point must be the load addr + %lu\n",
cmdname, (unsigned long)sizeof(image_header_t));
exit(EXIT_FAILURE);
}
}
imagefile = *argv;
if (lflag)
{
ifd = open(imagefile, O_RDONLY | O_BINARY);
}
else
{
ifd =
open(imagefile, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0666);
}
if (ifd < 0)
{
fprintf(stderr, "%s: Can't open %s: %s\n",
cmdname, imagefile, strerror(errno));
exit(EXIT_FAILURE);
}
if (lflag)
{
int len;
char *data;
/*
* list header information of existing image
*/
if (fstat(ifd, &sbuf) < 0)
{
fprintf(stderr, "%s: Can't stat %s: %s\n",
cmdname, imagefile, strerror(errno));
exit(EXIT_FAILURE);
}
if ((unsigned)sbuf.st_size < sizeof(image_header_t))
{
fprintf(stderr,
"%s: Bad size: \"%s\" is no valid image\n",
cmdname, imagefile);
exit(EXIT_FAILURE);
}
ptr = (unsigned char *)mmap(0, sbuf.st_size,
PROT_READ, MAP_SHARED, ifd, 0);
if ((caddr_t) ptr == (caddr_t) - 1)
{
fprintf(stderr, "%s: Can't read %s: %s\n",
cmdname, imagefile, strerror(errno));
exit(EXIT_FAILURE);
}
/*
* create copy of header so that we can blank out the
* checksum field for checking - this can't be done
* on the PROT_READ mapped data.
*/
memcpy(hdr, ptr, sizeof(image_header_t));
if (ntohl(hdr->ih_magic) != IH_MAGIC)
{
fprintf(stderr,
"%s: Bad Magic Number: \"%s\" is no valid image\n",
cmdname, imagefile);
exit(EXIT_FAILURE);
}
data = (char *)hdr;
len = sizeof(image_header_t);
checksum = ntohl(hdr->ih_hcrc);
hdr->ih_hcrc = htonl(0); /* clear for re-calculation */
if (crc32(0, data, len) != checksum)
{
fprintf(stderr,
"*** Warning: \"%s\" has bad header checksum!\n",
imagefile);
}
data = (char *)(ptr + sizeof(image_header_t));
len = sbuf.st_size - sizeof(image_header_t);
if (crc32(0, data, len) != ntohl(hdr->ih_dcrc))
{
fprintf(stderr,
"*** Warning: \"%s\" has corrupted data!\n",
imagefile);
}
/* for multi-file images we need the data part, too */
print_header((image_header_t *) ptr);
(void)munmap((void *)ptr, sbuf.st_size);
(void)close(ifd);
exit(EXIT_SUCCESS);
}
/*
* Must be -w then:
*
* write dummy header, to be fixed later
*/
memset(hdr, 0, sizeof(image_header_t));
if (write(ifd, hdr, sizeof(image_header_t)) != sizeof(image_header_t))
{
fprintf(stderr, "%s: Write error on %s: %s\n",
cmdname, imagefile, strerror(errno));
exit(EXIT_FAILURE);
}
if (opt_type == IH_TYPE_MULTI || opt_type == IH_TYPE_SCRIPT)
{
char *file = datafile;
unsigned long size;
for (;;)
{
char *sep = NULL;
if (file)
{
if ((sep = strchr(file, ':')) != NULL)
{
*sep = '\0';
}
if (stat(file, &sbuf) < 0)
{
fprintf(stderr, "%s: Can't stat %s: %s\n",
cmdname, file, strerror(errno));
exit(EXIT_FAILURE);
}
size = htonl(sbuf.st_size);
}
else
{
size = 0;
}
if (write(ifd, (char *)&size, sizeof(size)) != sizeof(size))
{
fprintf(stderr, "%s: Write error on %s: %s\n",
cmdname, imagefile, strerror(errno));
exit(EXIT_FAILURE);
}
if (!file)
{
break;
}
if (sep)
{
*sep = ':';
file = sep + 1;
}
else
{
file = NULL;
}
}
file = datafile;
for (;;)
{
char *sep = strchr(file, ':');
if (sep)
{
*sep = '\0';
copy_file(ifd, file, 1);
*sep++ = ':';
file = sep;
}
else
{
copy_file(ifd, file, 0);
break;
}
}
}
else
{
copy_file(ifd, datafile, 0);
}
/* We're a bit of paranoid */
#if defined(_POSIX_SYNCHRONIZED_IO) && !defined(__sun__) && !defined(__FreeBSD__)
(void)fdatasync(ifd);
#else
(void)fsync(ifd);
#endif
if (fstat(ifd, &sbuf) < 0)
{
fprintf(stderr, "%s: Can't stat %s: %s\n",
cmdname, imagefile, strerror(errno));
exit(EXIT_FAILURE);
}
ptr = (unsigned char *)mmap(0, sbuf.st_size,
PROT_READ | PROT_WRITE, MAP_SHARED, ifd,
0);
if (ptr == (unsigned char *)MAP_FAILED)
{
fprintf(stderr, "%s: Can't map %s: %s\n",
cmdname, imagefile, strerror(errno));
exit(EXIT_FAILURE);
}
hdr = (image_header_t *) ptr;
checksum = crc32(0,
(const char *)(ptr + sizeof(image_header_t)),
sbuf.st_size - sizeof(image_header_t));
/* Build new header */
hdr->ih_magic = htonl(IH_MAGIC);
hdr->ih_time = htonl(sbuf.st_mtime);
hdr->ih_size = htonl(sbuf.st_size - sizeof(image_header_t));
hdr->ih_load = htonl(addr);
hdr->ih_ep = htonl(ep);
hdr->ih_dcrc = htonl(checksum);
hdr->ih_os = opt_os;
hdr->ih_arch = opt_arch;
hdr->ih_type = opt_type;
hdr->ih_comp = opt_comp;
strncpy((char *)hdr->ih_name, name, IH_NMLEN);
checksum = crc32(0, (const char *)hdr, sizeof(image_header_t));
hdr->ih_hcrc = htonl(checksum);
print_header(hdr);
(void)munmap((void *)ptr, sbuf.st_size);
/* We're a bit of paranoid */
#if defined(_POSIX_SYNCHRONIZED_IO) && !defined(__sun__) && !defined(__FreeBSD__)
(void)fdatasync(ifd);
#else
(void)fsync(ifd);
#endif
if (close(ifd))
{
fprintf(stderr, "%s: Write error on %s: %s\n",
cmdname, imagefile, strerror(errno));
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
/* store registers in the guest state (gdbserver_to_valgrind)
or fetch register from the guest state (valgrind_to_gdbserver). */
static
void transfer_register (ThreadId tid, int abs_regno, void * buf,
transfer_direction dir, int size, Bool *mod)
{
ThreadState* tst = VG_(get_ThreadState)(tid);
int set = abs_regno / num_regs;
int regno = abs_regno % num_regs;
*mod = False;
VexGuestS390XState* s390x = (VexGuestS390XState*) get_arch (set, tst);
switch (regno) {
// numbers here have to match the order of regs above
// Attention: gdb order does not match valgrind order.
case 0: *mod = False; break; //GDBTD??? { "pswm", 0, 64 },
case 1: VG_(transfer) (&s390x->guest_IA, buf, dir, size, mod); break;
case 2: VG_(transfer) (&s390x->guest_r0, buf, dir, size, mod); break;
case 3: VG_(transfer) (&s390x->guest_r1, buf, dir, size, mod); break;
case 4: VG_(transfer) (&s390x->guest_r2, buf, dir, size, mod); break;
case 5: VG_(transfer) (&s390x->guest_r3, buf, dir, size, mod); break;
case 6: VG_(transfer) (&s390x->guest_r4, buf, dir, size, mod); break;
case 7: VG_(transfer) (&s390x->guest_r5, buf, dir, size, mod); break;
case 8: VG_(transfer) (&s390x->guest_r6, buf, dir, size, mod); break;
case 9: VG_(transfer) (&s390x->guest_r7, buf, dir, size, mod); break;
case 10: VG_(transfer) (&s390x->guest_r8, buf, dir, size, mod); break;
case 11: VG_(transfer) (&s390x->guest_r9, buf, dir, size, mod); break;
case 12: VG_(transfer) (&s390x->guest_r10, buf, dir, size, mod); break;
case 13: VG_(transfer) (&s390x->guest_r11, buf, dir, size, mod); break;
case 14: VG_(transfer) (&s390x->guest_r12, buf, dir, size, mod); break;
case 15: VG_(transfer) (&s390x->guest_r13, buf, dir, size, mod); break;
case 16: VG_(transfer) (&s390x->guest_r14, buf, dir, size, mod); break;
case 17: VG_(transfer) (&s390x->guest_r15, buf, dir, size, mod); break;
case 18: VG_(transfer) (&s390x->guest_a0, buf, dir, size, mod); break;
case 19: VG_(transfer) (&s390x->guest_a1, buf, dir, size, mod); break;
case 20: VG_(transfer) (&s390x->guest_a2, buf, dir, size, mod); break;
case 21: VG_(transfer) (&s390x->guest_a3, buf, dir, size, mod); break;
case 22: VG_(transfer) (&s390x->guest_a4, buf, dir, size, mod); break;
case 23: VG_(transfer) (&s390x->guest_a5, buf, dir, size, mod); break;
case 24: VG_(transfer) (&s390x->guest_a6, buf, dir, size, mod); break;
case 25: VG_(transfer) (&s390x->guest_a7, buf, dir, size, mod); break;
case 26: VG_(transfer) (&s390x->guest_a8, buf, dir, size, mod); break;
case 27: VG_(transfer) (&s390x->guest_a9, buf, dir, size, mod); break;
case 28: VG_(transfer) (&s390x->guest_a10, buf, dir, size, mod); break;
case 29: VG_(transfer) (&s390x->guest_a11, buf, dir, size, mod); break;
case 30: VG_(transfer) (&s390x->guest_a12, buf, dir, size, mod); break;
case 31: VG_(transfer) (&s390x->guest_a13, buf, dir, size, mod); break;
case 32: VG_(transfer) (&s390x->guest_a14, buf, dir, size, mod); break;
case 33: VG_(transfer) (&s390x->guest_a15, buf, dir, size, mod); break;
case 34: VG_(transfer) (&s390x->guest_fpc, buf, dir, size, mod); break;
case 35: VG_(transfer) (&s390x->guest_f0, buf, dir, size, mod); break;
case 36: VG_(transfer) (&s390x->guest_f1, buf, dir, size, mod); break;
case 37: VG_(transfer) (&s390x->guest_f2, buf, dir, size, mod); break;
case 38: VG_(transfer) (&s390x->guest_f3, buf, dir, size, mod); break;
case 39: VG_(transfer) (&s390x->guest_f4, buf, dir, size, mod); break;
case 40: VG_(transfer) (&s390x->guest_f5, buf, dir, size, mod); break;
case 41: VG_(transfer) (&s390x->guest_f6, buf, dir, size, mod); break;
case 42: VG_(transfer) (&s390x->guest_f7, buf, dir, size, mod); break;
case 43: VG_(transfer) (&s390x->guest_f8, buf, dir, size, mod); break;
case 44: VG_(transfer) (&s390x->guest_f9, buf, dir, size, mod); break;
case 45: VG_(transfer) (&s390x->guest_f10, buf, dir, size, mod); break;
case 46: VG_(transfer) (&s390x->guest_f11, buf, dir, size, mod); break;
case 47: VG_(transfer) (&s390x->guest_f12, buf, dir, size, mod); break;
case 48: VG_(transfer) (&s390x->guest_f13, buf, dir, size, mod); break;
case 49: VG_(transfer) (&s390x->guest_f14, buf, dir, size, mod); break;
case 50: VG_(transfer) (&s390x->guest_f15, buf, dir, size, mod); break;
case 51: *mod = False; break; //GDBTD??? { "orig_r2", 0, 64 },
default: vg_assert(0);
}
}
/* store registers in the guest state (gdbserver_to_valgrind)
or fetch register from the guest state (valgrind_to_gdbserver). */
static
void transfer_register (ThreadId tid, int abs_regno, void * buf,
transfer_direction dir, int size, Bool *mod)
{
ThreadState* tst = VG_(get_ThreadState)(tid);
int set = abs_regno / dyn_num_regs;
int regno = abs_regno % dyn_num_regs;
*mod = False;
VexGuestAMD64State* amd64 = (VexGuestAMD64State*) get_arch (set, tst);
switch (regno) {
// numbers here have to match the order of regs above.
// Attention: gdb order does not match valgrind order.
case 0:
VG_(transfer) (&amd64->guest_RAX, buf, dir, size, mod);
break;
case 1:
VG_(transfer) (&amd64->guest_RBX, buf, dir, size, mod);
break;
case 2:
VG_(transfer) (&amd64->guest_RCX, buf, dir, size, mod);
break;
case 3:
VG_(transfer) (&amd64->guest_RDX, buf, dir, size, mod);
break;
case 4:
VG_(transfer) (&amd64->guest_RSI, buf, dir, size, mod);
break;
case 5:
VG_(transfer) (&amd64->guest_RDI, buf, dir, size, mod);
break;
case 6:
VG_(transfer) (&amd64->guest_RBP, buf, dir, size, mod);
break;
case 7:
VG_(transfer) (&amd64->guest_RSP, buf, dir, size, mod);
break;
case 8:
VG_(transfer) (&amd64->guest_R8, buf, dir, size, mod);
break;
case 9:
VG_(transfer) (&amd64->guest_R9, buf, dir, size, mod);
break;
case 10:
VG_(transfer) (&amd64->guest_R10, buf, dir, size, mod);
break;
case 11:
VG_(transfer) (&amd64->guest_R11, buf, dir, size, mod);
break;
case 12:
VG_(transfer) (&amd64->guest_R12, buf, dir, size, mod);
break;
case 13:
VG_(transfer) (&amd64->guest_R13, buf, dir, size, mod);
break;
case 14:
VG_(transfer) (&amd64->guest_R14, buf, dir, size, mod);
break;
case 15:
VG_(transfer) (&amd64->guest_R15, buf, dir, size, mod);
break;
case 16:
VG_(transfer) (&amd64->guest_RIP, buf, dir, size, mod);
break;
case 17:
if (dir == valgrind_to_gdbserver) {
ULong rflags;
/* we can only retrieve the real flags (set 0)
retrieving shadow flags is not ok */
if (set == 0)
rflags = LibVEX_GuestAMD64_get_rflags (amd64);
else
rflags = 0;
VG_(transfer) (&rflags, buf, dir, size, mod);
} else {
*mod = False; //GDBTD? how do we store rflags in libvex_guest_amd64.h ???
}
break;
case 18:
*mod = False;
break; //GDBTD VG_(transfer) (&amd64->guest_CS, buf, dir, size, mod);
case 19:
*mod = False;
break; //GDBTD VG_(transfer) (&amd64->guest_SS, buf, dir, size, mod);
case 20:
*mod = False;
break; //GDBTD VG_(transfer) (&amd64->guest_DS, buf, dir, size, mod);
case 21:
*mod = False;
break; //GDBTD VG_(transfer) (&amd64->guest_ES, buf, dir, size, mod);
case 22:
*mod = False;
break; //GDBTD VG_(transfer) (&amd64->guest_FS, buf, dir, size, mod);
case 23:
VG_(transfer) (&amd64->guest_GS_0x60, buf, dir, size, mod);
break;
case 24:
case 25:
case 26:
case 27: /* register 24 to 31 are float registers 80 bits but 64 bits in valgrind */
case 28:
case 29:
case 30:
case 31:
if (dir == valgrind_to_gdbserver) {
UChar fpreg80[10];
convert_f64le_to_f80le ((UChar *)&amd64->guest_FPREG[regno-16],
fpreg80);
VG_(transfer) (&fpreg80, buf, dir, sizeof(fpreg80), mod);
} else {
ULong fpreg64;
convert_f80le_to_f64le (buf, (UChar *)&fpreg64);
VG_(transfer) (&amd64->guest_FPREG[regno-16], &fpreg64,
dir, sizeof(fpreg64), mod);
}
break;
case 32:
if (dir == valgrind_to_gdbserver) {
// vex only models the rounding bits (see libvex_guest_amd64.h)
UWord value = 0x037f;
value |= amd64->guest_FPROUND << 10;
VG_(transfer)(&value, buf, dir, size, mod);
} else {
*mod = False; // GDBTD???? VEX equivalent fcrtl
}
break;
case 33:
if (dir == valgrind_to_gdbserver) {
UWord value = amd64->guest_FC3210;
value |= (amd64->guest_FTOP & 7) << 11;
VG_(transfer)(&value, buf, dir, size, mod);
} else {
*mod = False; // GDBTD???? VEX equivalent fstat
}
break;
case 34:
if (dir == valgrind_to_gdbserver) {
// vex doesn't model these precisely
UWord value =
((amd64->guest_FPTAG[0] ? 0 : 3) << 0) |
((amd64->guest_FPTAG[1] ? 0 : 3) << 2) |
((amd64->guest_FPTAG[2] ? 0 : 3) << 4) |
((amd64->guest_FPTAG[3] ? 0 : 3) << 6) |
((amd64->guest_FPTAG[4] ? 0 : 3) << 8) |
((amd64->guest_FPTAG[5] ? 0 : 3) << 10) |
((amd64->guest_FPTAG[6] ? 0 : 3) << 12) |
((amd64->guest_FPTAG[7] ? 0 : 3) << 14);
VG_(transfer)(&value, buf, dir, size, mod);
} else {
*mod = False; // GDBTD???? VEX equivalent ftag
}
break;
case 35:
*mod = False;
break; // GDBTD ??? equivalent of fiseg
case 36:
*mod = False;
break; // GDBTD ??? equivalent of fioff
case 37:
*mod = False;
break; // GDBTD ??? equivalent of foseg
case 38:
*mod = False;
break; // GDBTD ??? equivalent of fooff
case 39:
*mod = False;
break; // GDBTD ??? equivalent of fop
case 40:
VG_(transfer) (&amd64->guest_YMM0[0], buf, dir, size, mod);
break;
case 41:
VG_(transfer) (&amd64->guest_YMM1[0], buf, dir, size, mod);
break;
case 42:
VG_(transfer) (&amd64->guest_YMM2[0], buf, dir, size, mod);
break;
case 43:
VG_(transfer) (&amd64->guest_YMM3[0], buf, dir, size, mod);
break;
case 44:
VG_(transfer) (&amd64->guest_YMM4[0], buf, dir, size, mod);
break;
case 45:
VG_(transfer) (&amd64->guest_YMM5[0], buf, dir, size, mod);
break;
case 46:
VG_(transfer) (&amd64->guest_YMM6[0], buf, dir, size, mod);
break;
case 47:
VG_(transfer) (&amd64->guest_YMM7[0], buf, dir, size, mod);
break;
case 48:
VG_(transfer) (&amd64->guest_YMM8[0], buf, dir, size, mod);
break;
case 49:
VG_(transfer) (&amd64->guest_YMM9[0], buf, dir, size, mod);
break;
case 50:
VG_(transfer) (&amd64->guest_YMM10[0], buf, dir, size, mod);
break;
case 51:
VG_(transfer) (&amd64->guest_YMM11[0], buf, dir, size, mod);
break;
case 52:
VG_(transfer) (&amd64->guest_YMM12[0], buf, dir, size, mod);
break;
case 53:
VG_(transfer) (&amd64->guest_YMM13[0], buf, dir, size, mod);
break;
case 54:
VG_(transfer) (&amd64->guest_YMM14[0], buf, dir, size, mod);
break;
case 55:
VG_(transfer) (&amd64->guest_YMM15[0], buf, dir, size, mod);
break;
case 56:
if (dir == valgrind_to_gdbserver) {
// vex only models the rounding bits (see libvex_guest_x86.h)
UWord value = 0x1f80;
value |= amd64->guest_SSEROUND << 13;
VG_(transfer)(&value, buf, dir, size, mod);
} else {
*mod = False; // GDBTD???? VEX equivalent mxcsr
}
break;
case 57:
*mod = False;
break; // GDBTD???? VEX equivalent { "orig_rax"},
case 58:
VG_(transfer) (&amd64->guest_YMM0[4], buf, dir, size, mod);
break;
case 59:
VG_(transfer) (&amd64->guest_YMM1[4], buf, dir, size, mod);
break;
case 60:
VG_(transfer) (&amd64->guest_YMM2[4], buf, dir, size, mod);
break;
case 61:
VG_(transfer) (&amd64->guest_YMM3[4], buf, dir, size, mod);
break;
case 62:
VG_(transfer) (&amd64->guest_YMM4[4], buf, dir, size, mod);
break;
case 63:
VG_(transfer) (&amd64->guest_YMM5[4], buf, dir, size, mod);
break;
case 64:
VG_(transfer) (&amd64->guest_YMM6[4], buf, dir, size, mod);
break;
case 65:
VG_(transfer) (&amd64->guest_YMM7[4], buf, dir, size, mod);
break;
case 66:
VG_(transfer) (&amd64->guest_YMM8[4], buf, dir, size, mod);
break;
case 67:
VG_(transfer) (&amd64->guest_YMM9[4], buf, dir, size, mod);
break;
case 68:
VG_(transfer) (&amd64->guest_YMM10[4], buf, dir, size, mod);
break;
case 69:
VG_(transfer) (&amd64->guest_YMM11[4], buf, dir, size, mod);
break;
case 70:
VG_(transfer) (&amd64->guest_YMM12[4], buf, dir, size, mod);
break;
case 71:
VG_(transfer) (&amd64->guest_YMM13[4], buf, dir, size, mod);
break;
case 72:
VG_(transfer) (&amd64->guest_YMM14[4], buf, dir, size, mod);
break;
case 73:
VG_(transfer) (&amd64->guest_YMM15[4], buf, dir, size, mod);
break;
default:
vg_assert(0);
}
}
bool get_sdk_self_registered_dir(pal::string_t* recv)
{
#if !defined(_TARGET_AMD64_) && !defined(_TARGET_X86_)
// Self-registered SDK installation directory is only supported for x64 and x86 architectures.
return false;
#else
recv->clear();
// ***Used only for testing***
pal::string_t environmentOverride;
if (pal::getenv(_X("_DOTNET_TEST_SDK_SELF_REGISTERED_DIR"), &environmentOverride))
{
recv->assign(environmentOverride);
return true;
}
// ***************************
DWORD size = 0;
const HKEY hkey = HKEY_LOCAL_MACHINE;
// The registry search occurs in the 32-bit registry in all cases.
const DWORD flags = RRF_RT_REG_SZ | RRF_SUBKEY_WOW6432KEY;
pal::string_t sub_key = pal::string_t(_X("SOFTWARE\\dotnet\\Setup\\InstalledVersions\\")) + get_arch() + pal::string_t(_X("\\sdk"));
pal::char_t* value = _X("InstallLocation");
// Determine the size of the buffer
LONG result = ::RegGetValueW(hkey, sub_key.c_str(), value, flags, nullptr, nullptr, &size);
if (result != ERROR_SUCCESS || size == 0)
{
return false;
}
// Get the key's value
std::vector<pal::char_t> buffer(size/sizeof(pal::char_t));
result = ::RegGetValueW(hkey, sub_key.c_str(), value, flags, nullptr, &buffer[0], &size);
if (result != ERROR_SUCCESS)
{
return false;
}
recv->assign(buffer.data());
return true;
#endif
}
/* store registers in the guest state (gdbserver_to_valgrind)
or fetch register from the guest state (valgrind_to_gdbserver). */
static
void transfer_register (ThreadId tid, int abs_regno, void * buf,
transfer_direction dir, int size, Bool *mod)
{
ThreadState* tst = VG_(get_ThreadState)(tid);
int set = abs_regno / num_regs;
int regno = abs_regno % num_regs;
*mod = False;
VexGuestARM64State* arm = (VexGuestARM64State*) get_arch (set, tst);
switch (regno) {
// numbers here have to match the order of regs above
// Attention: gdb order does not match valgrind order.
case 0: VG_(transfer) (&arm->guest_X0, buf, dir, size, mod); break;
case 1: VG_(transfer) (&arm->guest_X1, buf, dir, size, mod); break;
case 2: VG_(transfer) (&arm->guest_X2, buf, dir, size, mod); break;
case 3: VG_(transfer) (&arm->guest_X3, buf, dir, size, mod); break;
case 4: VG_(transfer) (&arm->guest_X4, buf, dir, size, mod); break;
case 5: VG_(transfer) (&arm->guest_X5, buf, dir, size, mod); break;
case 6: VG_(transfer) (&arm->guest_X6, buf, dir, size, mod); break;
case 7: VG_(transfer) (&arm->guest_X7, buf, dir, size, mod); break;
case 8: VG_(transfer) (&arm->guest_X8, buf, dir, size, mod); break;
case 9: VG_(transfer) (&arm->guest_X9, buf, dir, size, mod); break;
case 10: VG_(transfer) (&arm->guest_X10, buf, dir, size, mod); break;
case 11: VG_(transfer) (&arm->guest_X11, buf, dir, size, mod); break;
case 12: VG_(transfer) (&arm->guest_X12, buf, dir, size, mod); break;
case 13: VG_(transfer) (&arm->guest_X13, buf, dir, size, mod); break;
case 14: VG_(transfer) (&arm->guest_X14, buf, dir, size, mod); break;
case 15: VG_(transfer) (&arm->guest_X15, buf, dir, size, mod); break;
case 16: VG_(transfer) (&arm->guest_X16, buf, dir, size, mod); break;
case 17: VG_(transfer) (&arm->guest_X17, buf, dir, size, mod); break;
case 18: VG_(transfer) (&arm->guest_X18, buf, dir, size, mod); break;
case 19: VG_(transfer) (&arm->guest_X19, buf, dir, size, mod); break;
case 20: VG_(transfer) (&arm->guest_X20, buf, dir, size, mod); break;
case 21: VG_(transfer) (&arm->guest_X21, buf, dir, size, mod); break;
case 22: VG_(transfer) (&arm->guest_X22, buf, dir, size, mod); break;
case 23: VG_(transfer) (&arm->guest_X23, buf, dir, size, mod); break;
case 24: VG_(transfer) (&arm->guest_X24, buf, dir, size, mod); break;
case 25: VG_(transfer) (&arm->guest_X25, buf, dir, size, mod); break;
case 26: VG_(transfer) (&arm->guest_X26, buf, dir, size, mod); break;
case 27: VG_(transfer) (&arm->guest_X27, buf, dir, size, mod); break;
case 28: VG_(transfer) (&arm->guest_X28, buf, dir, size, mod); break;
case 29: VG_(transfer) (&arm->guest_X29, buf, dir, size, mod); break;
case 30: VG_(transfer) (&arm->guest_X30, buf, dir, size, mod); break;
case 31: VG_(transfer) (&arm->guest_XSP, buf, dir, size, mod); break;
case 32: VG_(transfer) (&arm->guest_PC, buf, dir, size, mod); break;
case 33: *mod = False; // GDBTD cpsr what to do for arm64 ???
case 34: VG_(transfer) (&arm->guest_Q0, buf, dir, size, mod); break;
case 35: VG_(transfer) (&arm->guest_Q1, buf, dir, size, mod); break;
case 36: VG_(transfer) (&arm->guest_Q2, buf, dir, size, mod); break;
case 37: VG_(transfer) (&arm->guest_Q3, buf, dir, size, mod); break;
case 38: VG_(transfer) (&arm->guest_Q4, buf, dir, size, mod); break;
case 39: VG_(transfer) (&arm->guest_Q5, buf, dir, size, mod); break;
case 40: VG_(transfer) (&arm->guest_Q6, buf, dir, size, mod); break;
case 41: VG_(transfer) (&arm->guest_Q7, buf, dir, size, mod); break;
case 42: VG_(transfer) (&arm->guest_Q8, buf, dir, size, mod); break;
case 43: VG_(transfer) (&arm->guest_Q9, buf, dir, size, mod); break;
case 44: VG_(transfer) (&arm->guest_Q10, buf, dir, size, mod); break;
case 45: VG_(transfer) (&arm->guest_Q11, buf, dir, size, mod); break;
case 46: VG_(transfer) (&arm->guest_Q12, buf, dir, size, mod); break;
case 47: VG_(transfer) (&arm->guest_Q13, buf, dir, size, mod); break;
case 48: VG_(transfer) (&arm->guest_Q14, buf, dir, size, mod); break;
case 49: VG_(transfer) (&arm->guest_Q15, buf, dir, size, mod); break;
case 50: VG_(transfer) (&arm->guest_Q16, buf, dir, size, mod); break;
case 51: VG_(transfer) (&arm->guest_Q17, buf, dir, size, mod); break;
case 52: VG_(transfer) (&arm->guest_Q18, buf, dir, size, mod); break;
case 53: VG_(transfer) (&arm->guest_Q19, buf, dir, size, mod); break;
case 54: VG_(transfer) (&arm->guest_Q20, buf, dir, size, mod); break;
case 55: VG_(transfer) (&arm->guest_Q21, buf, dir, size, mod); break;
case 56: VG_(transfer) (&arm->guest_Q22, buf, dir, size, mod); break;
case 57: VG_(transfer) (&arm->guest_Q23, buf, dir, size, mod); break;
case 58: VG_(transfer) (&arm->guest_Q24, buf, dir, size, mod); break;
case 59: VG_(transfer) (&arm->guest_Q25, buf, dir, size, mod); break;
case 60: VG_(transfer) (&arm->guest_Q26, buf, dir, size, mod); break;
case 61: VG_(transfer) (&arm->guest_Q27, buf, dir, size, mod); break;
case 62: VG_(transfer) (&arm->guest_Q28, buf, dir, size, mod); break;
case 63: VG_(transfer) (&arm->guest_Q29, buf, dir, size, mod); break;
case 64: VG_(transfer) (&arm->guest_Q30, buf, dir, size, mod); break;
case 65: VG_(transfer) (&arm->guest_Q31, buf, dir, size, mod); break;
case 66: {
/* The VEX ARM64 FPSR representation is not the same as the
architecturally defined representation. Hence use conversion
functions to convert to/from it.
VEX FPSR only models QC (bit 27), and uses a 64 bits to store
this FPSR QC bit. So, we need to transfer from/to the lowest
significant part of the ULong that VEX provides/needs,
as GDB expects or gives only 4 bytes. */
if (dir == valgrind_to_gdbserver) {
ULong fpsr64 = LibVEX_GuestARM64_get_fpsr(arm);
UInt fpsr = (UInt)fpsr64;
VG_(transfer) (&fpsr, buf, dir, size, mod);
} else {
UInt fpsr;
ULong fpsr64;
VG_(transfer) ((UInt*)&fpsr, buf, dir, size, mod);
fpsr64 = fpsr;
LibVEX_GuestARM64_set_fpsr(arm, fpsr64);
/* resync the cache with the part of fpsr that VEX represents. */
fpsr64 = LibVEX_GuestARM64_get_fpsr(arm);
fpsr = (UInt)fpsr64;
VG_(transfer) (&fpsr, buf, valgrind_to_gdbserver, size, mod);
}
break;
}
case 67: VG_(transfer) (&arm->guest_FPCR, buf, dir, size, mod); break;
default: vg_assert(0);
}
}
/* store registers in the guest state (gdbserver_to_valgrind)
or fetch register from the guest state (valgrind_to_gdbserver). */
static
void transfer_register (ThreadId tid, int abs_regno, void * buf,
transfer_direction dir, int size, Bool *mod)
{
ThreadState* tst = VG_(get_ThreadState)(tid);
int set = abs_regno / num_regs;
int regno = abs_regno % num_regs;
*mod = False;
VexGuestPPC32State* ppc32 = (VexGuestPPC32State*) get_arch (set, tst);
switch (regno) {
// numbers here have to match the order of regs above
// Attention: gdb order does not match valgrind order.
case 0: VG_(transfer) (&ppc32->guest_GPR0, buf, dir, size, mod); break;
case 1: VG_(transfer) (&ppc32->guest_GPR1, buf, dir, size, mod); break;
case 2: VG_(transfer) (&ppc32->guest_GPR2, buf, dir, size, mod); break;
case 3: VG_(transfer) (&ppc32->guest_GPR3, buf, dir, size, mod); break;
case 4: VG_(transfer) (&ppc32->guest_GPR4, buf, dir, size, mod); break;
case 5: VG_(transfer) (&ppc32->guest_GPR5, buf, dir, size, mod); break;
case 6: VG_(transfer) (&ppc32->guest_GPR6, buf, dir, size, mod); break;
case 7: VG_(transfer) (&ppc32->guest_GPR7, buf, dir, size, mod); break;
case 8: VG_(transfer) (&ppc32->guest_GPR8, buf, dir, size, mod); break;
case 9: VG_(transfer) (&ppc32->guest_GPR9, buf, dir, size, mod); break;
case 10: VG_(transfer) (&ppc32->guest_GPR10, buf, dir, size, mod); break;
case 11: VG_(transfer) (&ppc32->guest_GPR11, buf, dir, size, mod); break;
case 12: VG_(transfer) (&ppc32->guest_GPR12, buf, dir, size, mod); break;
case 13: VG_(transfer) (&ppc32->guest_GPR13, buf, dir, size, mod); break;
case 14: VG_(transfer) (&ppc32->guest_GPR14, buf, dir, size, mod); break;
case 15: VG_(transfer) (&ppc32->guest_GPR15, buf, dir, size, mod); break;
case 16: VG_(transfer) (&ppc32->guest_GPR16, buf, dir, size, mod); break;
case 17: VG_(transfer) (&ppc32->guest_GPR17, buf, dir, size, mod); break;
case 18: VG_(transfer) (&ppc32->guest_GPR18, buf, dir, size, mod); break;
case 19: VG_(transfer) (&ppc32->guest_GPR19, buf, dir, size, mod); break;
case 20: VG_(transfer) (&ppc32->guest_GPR20, buf, dir, size, mod); break;
case 21: VG_(transfer) (&ppc32->guest_GPR21, buf, dir, size, mod); break;
case 22: VG_(transfer) (&ppc32->guest_GPR22, buf, dir, size, mod); break;
case 23: VG_(transfer) (&ppc32->guest_GPR23, buf, dir, size, mod); break;
case 24: VG_(transfer) (&ppc32->guest_GPR24, buf, dir, size, mod); break;
case 25: VG_(transfer) (&ppc32->guest_GPR25, buf, dir, size, mod); break;
case 26: VG_(transfer) (&ppc32->guest_GPR26, buf, dir, size, mod); break;
case 27: VG_(transfer) (&ppc32->guest_GPR27, buf, dir, size, mod); break;
case 28: VG_(transfer) (&ppc32->guest_GPR28, buf, dir, size, mod); break;
case 29: VG_(transfer) (&ppc32->guest_GPR29, buf, dir, size, mod); break;
case 30: VG_(transfer) (&ppc32->guest_GPR30, buf, dir, size, mod); break;
case 31: VG_(transfer) (&ppc32->guest_GPR31, buf, dir, size, mod); break;
case 32: VG_(transfer) (&ppc32->guest_VSR0, buf, dir, size, mod); break;
case 33: VG_(transfer) (&ppc32->guest_VSR1, buf, dir, size, mod); break;
case 34: VG_(transfer) (&ppc32->guest_VSR2, buf, dir, size, mod); break;
case 35: VG_(transfer) (&ppc32->guest_VSR3, buf, dir, size, mod); break;
case 36: VG_(transfer) (&ppc32->guest_VSR4, buf, dir, size, mod); break;
case 37: VG_(transfer) (&ppc32->guest_VSR5, buf, dir, size, mod); break;
case 38: VG_(transfer) (&ppc32->guest_VSR6, buf, dir, size, mod); break;
case 39: VG_(transfer) (&ppc32->guest_VSR7, buf, dir, size, mod); break;
case 40: VG_(transfer) (&ppc32->guest_VSR8, buf, dir, size, mod); break;
case 41: VG_(transfer) (&ppc32->guest_VSR9, buf, dir, size, mod); break;
case 42: VG_(transfer) (&ppc32->guest_VSR10, buf, dir, size, mod); break;
case 43: VG_(transfer) (&ppc32->guest_VSR11, buf, dir, size, mod); break;
case 44: VG_(transfer) (&ppc32->guest_VSR12, buf, dir, size, mod); break;
case 45: VG_(transfer) (&ppc32->guest_VSR13, buf, dir, size, mod); break;
case 46: VG_(transfer) (&ppc32->guest_VSR14, buf, dir, size, mod); break;
case 47: VG_(transfer) (&ppc32->guest_VSR15, buf, dir, size, mod); break;
case 48: VG_(transfer) (&ppc32->guest_VSR16, buf, dir, size, mod); break;
case 49: VG_(transfer) (&ppc32->guest_VSR17, buf, dir, size, mod); break;
case 50: VG_(transfer) (&ppc32->guest_VSR18, buf, dir, size, mod); break;
case 51: VG_(transfer) (&ppc32->guest_VSR19, buf, dir, size, mod); break;
case 52: VG_(transfer) (&ppc32->guest_VSR20, buf, dir, size, mod); break;
case 53: VG_(transfer) (&ppc32->guest_VSR21, buf, dir, size, mod); break;
case 54: VG_(transfer) (&ppc32->guest_VSR22, buf, dir, size, mod); break;
case 55: VG_(transfer) (&ppc32->guest_VSR23, buf, dir, size, mod); break;
case 56: VG_(transfer) (&ppc32->guest_VSR24, buf, dir, size, mod); break;
case 57: VG_(transfer) (&ppc32->guest_VSR25, buf, dir, size, mod); break;
case 58: VG_(transfer) (&ppc32->guest_VSR26, buf, dir, size, mod); break;
case 59: VG_(transfer) (&ppc32->guest_VSR27, buf, dir, size, mod); break;
case 60: VG_(transfer) (&ppc32->guest_VSR28, buf, dir, size, mod); break;
case 61: VG_(transfer) (&ppc32->guest_VSR29, buf, dir, size, mod); break;
case 62: VG_(transfer) (&ppc32->guest_VSR30, buf, dir, size, mod); break;
case 63: VG_(transfer) (&ppc32->guest_VSR31, buf, dir, size, mod); break;
case 64: VG_(transfer) (&ppc32->guest_CIA, buf, dir, size, mod); break;
case 65: *mod = False; break; // VEX does not model Machine State Register
case 66: {
UInt cr = LibVEX_GuestPPC32_get_CR (ppc32);
if (dir == valgrind_to_gdbserver) {
VG_(transfer) (&cr, buf, dir, size, mod);
} else {
UInt newcr;
VG_(transfer) (&newcr, buf, dir, size, mod);
*mod = newcr != cr;
LibVEX_GuestPPC32_put_CR (newcr, ppc32);
}
break;
}
case 67: VG_(transfer) (&ppc32->guest_LR, buf, dir, size, mod); break;
case 68: VG_(transfer) (&ppc32->guest_CTR, buf, dir, size, mod); break;
case 69: {
UInt xer = LibVEX_GuestPPC32_get_XER (ppc32);
if (dir == valgrind_to_gdbserver) {
VG_(transfer) (&xer, buf, dir, size, mod);
} else {
UInt newxer;
VG_(transfer) (&newxer, buf, dir, size, mod);
*mod = newxer != xer;
LibVEX_GuestPPC32_put_XER (newxer, ppc32);
}
break;
}
case 70: VG_(transfer) (&ppc32->guest_FPROUND, buf, dir, size, mod); break;
case 71: *mod = False; break; // GDBTD???? VEX { "orig_r3", 3296, 32 },
case 72: *mod = False; break; // GDBTD???? VEX { "trap", 3328, 32 },
case 73: VG_(transfer) (&ppc32->guest_VSR32, buf, dir, size, mod); break;
case 74: VG_(transfer) (&ppc32->guest_VSR33, buf, dir, size, mod); break;
case 75: VG_(transfer) (&ppc32->guest_VSR34, buf, dir, size, mod); break;
case 76: VG_(transfer) (&ppc32->guest_VSR35, buf, dir, size, mod); break;
case 77: VG_(transfer) (&ppc32->guest_VSR36, buf, dir, size, mod); break;
case 78: VG_(transfer) (&ppc32->guest_VSR37, buf, dir, size, mod); break;
case 79: VG_(transfer) (&ppc32->guest_VSR38, buf, dir, size, mod); break;
case 80: VG_(transfer) (&ppc32->guest_VSR39, buf, dir, size, mod); break;
case 81: VG_(transfer) (&ppc32->guest_VSR40, buf, dir, size, mod); break;
case 82: VG_(transfer) (&ppc32->guest_VSR41, buf, dir, size, mod); break;
case 83: VG_(transfer) (&ppc32->guest_VSR42, buf, dir, size, mod); break;
case 84: VG_(transfer) (&ppc32->guest_VSR43, buf, dir, size, mod); break;
case 85: VG_(transfer) (&ppc32->guest_VSR44, buf, dir, size, mod); break;
case 86: VG_(transfer) (&ppc32->guest_VSR45, buf, dir, size, mod); break;
case 87: VG_(transfer) (&ppc32->guest_VSR46, buf, dir, size, mod); break;
case 88: VG_(transfer) (&ppc32->guest_VSR47, buf, dir, size, mod); break;
case 89: VG_(transfer) (&ppc32->guest_VSR48, buf, dir, size, mod); break;
case 90: VG_(transfer) (&ppc32->guest_VSR49, buf, dir, size, mod); break;
case 91: VG_(transfer) (&ppc32->guest_VSR50, buf, dir, size, mod); break;
case 92: VG_(transfer) (&ppc32->guest_VSR51, buf, dir, size, mod); break;
case 93: VG_(transfer) (&ppc32->guest_VSR52, buf, dir, size, mod); break;
case 94: VG_(transfer) (&ppc32->guest_VSR53, buf, dir, size, mod); break;
case 95: VG_(transfer) (&ppc32->guest_VSR54, buf, dir, size, mod); break;
case 96: VG_(transfer) (&ppc32->guest_VSR55, buf, dir, size, mod); break;
case 97: VG_(transfer) (&ppc32->guest_VSR56, buf, dir, size, mod); break;
case 98: VG_(transfer) (&ppc32->guest_VSR57, buf, dir, size, mod); break;
case 99: VG_(transfer) (&ppc32->guest_VSR58, buf, dir, size, mod); break;
case 100: VG_(transfer) (&ppc32->guest_VSR59, buf, dir, size, mod); break;
case 101: VG_(transfer) (&ppc32->guest_VSR60, buf, dir, size, mod); break;
case 102: VG_(transfer) (&ppc32->guest_VSR61, buf, dir, size, mod); break;
case 103: VG_(transfer) (&ppc32->guest_VSR62, buf, dir, size, mod); break;
case 104: VG_(transfer) (&ppc32->guest_VSR63, buf, dir, size, mod); break;
case 105: VG_(transfer) (&ppc32->guest_VSCR, buf, dir, size, mod); break;
case 106: VG_(transfer) (&ppc32->guest_VRSAVE, buf, dir, size, mod); break;
default: vg_assert(0);
}
}
