mirror of
https://github.com/TomHarte/CLK.git
synced 2024-12-30 19:30:17 +00:00
208 lines
9.2 KiB
C++
208 lines
9.2 KiB
C++
//
|
|
// StaticAnalyser.cpp
|
|
// Clock Signal
|
|
//
|
|
// Created by Thomas Harte on 11/10/2016.
|
|
// Copyright 2016 Thomas Harte. All rights reserved.
|
|
//
|
|
|
|
#include "StaticAnalyser.hpp"
|
|
|
|
#include "Tape.hpp"
|
|
#include "Target.hpp"
|
|
|
|
#include "../Disassembler/6502.hpp"
|
|
#include "../Disassembler/AddressMapper.hpp"
|
|
|
|
#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
|
|
|
|
#include <cstring>
|
|
|
|
using namespace Analyser::Static::Oric;
|
|
|
|
namespace {
|
|
|
|
int score(const Analyser::Static::MOS6502::Disassembly &disassembly, const std::set<uint16_t> &rom_functions, const std::set<uint16_t> &variable_locations) {
|
|
int score = 0;
|
|
|
|
for(const auto address : disassembly.outward_calls) score += (rom_functions.find(address) != rom_functions.end()) ? 1 : -1;
|
|
for(const auto address : disassembly.external_stores) score += (variable_locations.find(address) != variable_locations.end()) ? 1 : -1;
|
|
for(const auto address : disassembly.external_loads) score += (variable_locations.find(address) != variable_locations.end()) ? 1 : -1;
|
|
|
|
return score;
|
|
}
|
|
|
|
int basic10_score(const Analyser::Static::MOS6502::Disassembly &disassembly) {
|
|
const std::set<uint16_t> rom_functions = {
|
|
0x0228, 0x022b,
|
|
0xc3ca, 0xc3f8, 0xc448, 0xc47c, 0xc4b5, 0xc4e3, 0xc4e0, 0xc524, 0xc56f, 0xc5a2, 0xc5f8, 0xc60a, 0xc6a5, 0xc6de, 0xc719, 0xc738,
|
|
0xc773, 0xc824, 0xc832, 0xc841, 0xc8c1, 0xc8fe, 0xc91f, 0xc93f, 0xc941, 0xc91e, 0xc98b, 0xc996, 0xc9b3, 0xc9e0, 0xca0a, 0xca1c,
|
|
0xca1f, 0xca3e, 0xca61, 0xca78, 0xca98, 0xcad2, 0xcb61, 0xcb9f, 0xcc59, 0xcbed, 0xcc0a, 0xcc8c, 0xcc8f, 0xccba, 0xccc9, 0xccfd,
|
|
0xce0c, 0xce77, 0xce8b, 0xcfac, 0xcf74, 0xd03c, 0xd059, 0xcff0, 0xd087, 0xd0f2, 0xd0fc, 0xd361, 0xd3eb, 0xd47e, 0xd4a6, 0xd401,
|
|
0xd593, 0xd5a3, 0xd4fa, 0xd595, 0xd730, 0xd767, 0xd816, 0xd82a, 0xd856, 0xd861, 0xd8a6, 0xd8b5, 0xd80a, 0xd867, 0xd938, 0xd894,
|
|
0xd89d, 0xd8ac, 0xd983, 0xd993, 0xd9b5, 0xd93d, 0xd965, 0xda3f, 0xd9c6, 0xda16, 0xdaab, 0xdada, 0xda6b, 0xdb92, 0xdbb9, 0xdc79,
|
|
0xdd4d, 0xdda3, 0xddbf, 0xd0d0, 0xde77, 0xdef4, 0xdf0b, 0xdf0f, 0xdf04, 0xdf12, 0xdf31, 0xdf4c, 0xdf8c, 0xdfa5, 0xdfcf, 0xe076,
|
|
0xe0c1, 0xe22a, 0xe27c, 0xe2a6, 0xe313, 0xe34b, 0xe387, 0xe38e, 0xe3d7, 0xe407, 0xe43b, 0xe46f, 0xe4a8, 0xe4f2, 0xe554, 0xe57d,
|
|
0xe585, 0xe58c, 0xe594, 0xe5a4, 0xe5ab, 0xe5b6, 0xe5ea, 0xe563, 0xe5c6, 0xe630, 0xe696, 0xe6ba, 0xe6ca, 0xe725, 0xe7aa, 0xe903,
|
|
0xe7db, 0xe80d, 0xe987, 0xe9d1, 0xe87d, 0xe905, 0xe965, 0xe974, 0xe994, 0xe9a9, 0xe9bb, 0xec45, 0xeccc, 0xedc4, 0xecc7, 0xed01,
|
|
0xed09, 0xed70, 0xed81, 0xed8f, 0xe0ad, 0xeee8, 0xeef8, 0xebdf, 0xebe2, 0xebe5, 0xebeb, 0xebee, 0xebf4, 0xebf7, 0xebfa, 0xebe8,
|
|
0xf43c, 0xf4ef, 0xf523, 0xf561, 0xf535, 0xf57b, 0xf5d3, 0xf71a, 0xf73f, 0xf7e4, 0xf7e0, 0xf82f, 0xf88f, 0xf8af, 0xf8b5, 0xf920,
|
|
0xf967, 0xf960, 0xf9c9, 0xfa14, 0xfa85, 0xfa9b, 0xfab1, 0xfac7, 0xfafa, 0xfb10, 0xfb26, 0xfbb6, 0xfbfe
|
|
};
|
|
const std::set<uint16_t> variable_locations = {
|
|
0x0228, 0x0229, 0x022a, 0x022b, 0x022c, 0x022d, 0x0230
|
|
};
|
|
|
|
return score(disassembly, rom_functions, variable_locations);
|
|
}
|
|
|
|
int basic11_score(const Analyser::Static::MOS6502::Disassembly &disassembly) {
|
|
const std::set<uint16_t> rom_functions = {
|
|
0x0238, 0x023b, 0x023e, 0x0241, 0x0244, 0x0247,
|
|
0xc3c6, 0xc3f4, 0xc444, 0xc47c, 0xc4a8, 0xc4d3, 0xc4e0, 0xc524, 0xc55f, 0xc592, 0xc5e8, 0xc5fa, 0xc692, 0xc6b3, 0xc6ee, 0xc70d,
|
|
0xc748, 0xc7fd, 0xc809, 0xc816, 0xc82f, 0xc855, 0xc8c1, 0xc915, 0xc952, 0xc971, 0xc973, 0xc9a0, 0xc9bd, 0xc9c8, 0xc9e5, 0xca12,
|
|
0xca3c, 0xca4e, 0xca51, 0xca70, 0xca99, 0xcac2, 0xcae2, 0xcb1c, 0xcbab, 0xcbf0, 0xcc59, 0xccb0, 0xccce, 0xcd16, 0xcd19, 0xcd46,
|
|
0xcd55, 0xcd89, 0xce98, 0xcf03, 0xcf17, 0xcfac, 0xd000, 0xd03c, 0xd059, 0xd07c, 0xd113, 0xd17e, 0xd188, 0xd361, 0xd3eb, 0xd47e,
|
|
0xd4a6, 0xd4ba, 0xd593, 0xd5a3, 0xd5b5, 0xd650, 0xd730, 0xd767, 0xd816, 0xd82a, 0xd856, 0xd861, 0xd8a6, 0xd8b5, 0xd8c5, 0xd922,
|
|
0xd938, 0xd94f, 0xd958, 0xd967, 0xd983, 0xd993, 0xd9b5, 0xd9de, 0xda0c, 0xda3f, 0xda51, 0xdaa1, 0xdaab, 0xdada, 0xdaf6, 0xdb92,
|
|
0xdbb9, 0xdcaf, 0xdd51, 0xdda7, 0xddc3, 0xddd4, 0xde77, 0xdef4, 0xdf0b, 0xdf0f, 0xdf13, 0xdf21, 0xdf49, 0xdf4c, 0xdf8c, 0xdfbd,
|
|
0xdfe7, 0xe076, 0xe0c5, 0xe22e, 0xe27c, 0xe2aa, 0xe313, 0xe34f, 0xe38b, 0xe392, 0xe3db, 0xe407, 0xe43f, 0xe46f, 0xe4ac, 0xe4e0,
|
|
0xe4f2, 0xe56c, 0xe57d, 0xe585, 0xe58c, 0xe594, 0xe5a4, 0xe5ab, 0xe5b6, 0xe5ea, 0xe5f5, 0xe607, 0xe65e, 0xe6c9, 0xe735, 0xe75a,
|
|
0xe76a, 0xe7b2, 0xe85b, 0xe903, 0xe909, 0xe946, 0xe987, 0xe9d1, 0xeaf0, 0xeb78, 0xebce, 0xebe7, 0xec0c, 0xec21, 0xec33, 0xec45,
|
|
0xeccc, 0xedc4, 0xede0, 0xee1a, 0xee22, 0xee8c, 0xee9d, 0xeeab, 0xeec9, 0xeee8, 0xeef8, 0xf0c8, 0xf0fd, 0xf110, 0xf11d, 0xf12d,
|
|
0xf204, 0xf210, 0xf268, 0xf37f, 0xf495, 0xf4ef, 0xf523, 0xf561, 0xf590, 0xf5c1, 0xf602, 0xf71a, 0xf77c, 0xf7e4, 0xf816, 0xf865,
|
|
0xf88f, 0xf8af, 0xf8b5, 0xf920, 0xf967, 0xf9aa, 0xf9c9, 0xfa14, 0xfa9f, 0xfab5, 0xfacb, 0xfae1, 0xfb14, 0xfb2a, 0xfb40, 0xfbd0,
|
|
0xfc18
|
|
};
|
|
const std::set<uint16_t> variable_locations = {
|
|
0x0244, 0x0245, 0x0246, 0x0247, 0x0248, 0x0249, 0x024a, 0x024b, 0x024c
|
|
};
|
|
|
|
return score(disassembly, rom_functions, variable_locations);
|
|
}
|
|
|
|
bool is_microdisc(Storage::Encodings::MFM::Parser &parser) {
|
|
/*
|
|
The Microdisc boot sector is sector 2 of track 0 and contains a 23-byte signature.
|
|
*/
|
|
Storage::Encodings::MFM::Sector *sector = parser.get_sector(0, 0, 2);
|
|
if(!sector) return false;
|
|
if(sector->samples.empty()) return false;
|
|
|
|
const std::vector<uint8_t> &first_sample = sector->samples[0];
|
|
if(first_sample.size() != 256) return false;
|
|
|
|
const uint8_t signature[] = {
|
|
0x00, 0x00, 0xFF, 0x00, 0xD0, 0x9F, 0xD0,
|
|
0x9F, 0x02, 0xB9, 0x01, 0x00, 0xFF, 0x00,
|
|
0x00, 0xB9, 0xE4, 0xB9, 0x00, 0x00, 0xE6,
|
|
0x12, 0x00
|
|
};
|
|
|
|
return !std::memcmp(signature, first_sample.data(), sizeof(signature));
|
|
}
|
|
|
|
bool is_400_loader(Storage::Encodings::MFM::Parser &parser, uint16_t range_start, uint16_t range_end) {
|
|
/*
|
|
Both the Jasmin and BD-DOS boot sectors are sector 1 of track 0 and are loaded at $400;
|
|
use disassembly to test for likely matches.
|
|
*/
|
|
|
|
Storage::Encodings::MFM::Sector *sector = parser.get_sector(0, 0, 1);
|
|
if(!sector) return false;
|
|
if(sector->samples.empty()) return false;
|
|
|
|
// Take a copy of the first sampling, and keep only the final 256 bytes (assuming at least that many were found).
|
|
std::vector<uint8_t> first_sample = sector->samples[0];
|
|
if(first_sample.size() < 256) return false;
|
|
if(first_sample.size() > 256) {
|
|
first_sample.erase(first_sample.end() - 256, first_sample.end());
|
|
}
|
|
|
|
// Grab a disassembly.
|
|
const auto disassembly =
|
|
Analyser::Static::MOS6502::Disassemble(first_sample, Analyser::Static::Disassembler::OffsetMapper(0x400), {0x400});
|
|
|
|
// Check for references to the Jasmin registers.
|
|
int register_hits = 0;
|
|
for(auto list : {disassembly.external_stores, disassembly.external_loads, disassembly.external_modifies}) {
|
|
for(auto address : list) {
|
|
register_hits += (address >= range_start && address <= range_end);
|
|
}
|
|
}
|
|
|
|
// Arbitrary, sure, but as long as at least two accesses to the requested register range are found, accept this.
|
|
return register_hits >= 2;
|
|
}
|
|
|
|
bool is_jasmin(Storage::Encodings::MFM::Parser &parser) {
|
|
return is_400_loader(parser, 0x3f4, 0x3ff);
|
|
}
|
|
|
|
bool is_bd500(Storage::Encodings::MFM::Parser &parser) {
|
|
return is_400_loader(parser, 0x310, 0x323);
|
|
}
|
|
|
|
}
|
|
|
|
Analyser::Static::TargetList Analyser::Static::Oric::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
|
|
auto target = std::make_unique<Target>();
|
|
target->confidence = 0.5;
|
|
|
|
int basic10_votes = 0;
|
|
int basic11_votes = 0;
|
|
|
|
for(auto &tape : media.tapes) {
|
|
std::vector<File> tape_files = GetFiles(tape);
|
|
tape->reset();
|
|
if(!tape_files.empty()) {
|
|
for(const auto &file : tape_files) {
|
|
if(file.data_type == File::MachineCode) {
|
|
std::vector<uint16_t> entry_points = {file.starting_address};
|
|
const Analyser::Static::MOS6502::Disassembly disassembly =
|
|
Analyser::Static::MOS6502::Disassemble(file.data, Analyser::Static::Disassembler::OffsetMapper(file.starting_address), entry_points);
|
|
|
|
if(basic10_score(disassembly) > basic11_score(disassembly)) ++basic10_votes; else ++basic11_votes;
|
|
}
|
|
}
|
|
|
|
target->media.tapes.push_back(tape);
|
|
target->loading_command = "CLOAD\"\"\n";
|
|
}
|
|
}
|
|
|
|
if(!media.disks.empty()) {
|
|
// 8-DOS is recognised by a dedicated Disk II analyser, so check only for Microdisc,
|
|
// Jasmin and BD-DOS formats here.
|
|
for(auto &disk: media.disks) {
|
|
Storage::Encodings::MFM::Parser parser(true, disk);
|
|
|
|
if(is_microdisc(parser)) {
|
|
target->disk_interface = Target::DiskInterface::Microdisc;
|
|
target->media.disks.push_back(disk);
|
|
} else if(is_jasmin(parser)) {
|
|
target->disk_interface = Target::DiskInterface::Jasmin;
|
|
target->should_start_jasmin = true;
|
|
target->media.disks.push_back(disk);
|
|
} else if(is_bd500(parser)) {
|
|
target->disk_interface = Target::DiskInterface::BD500;
|
|
target->media.disks.push_back(disk);
|
|
target->rom = Target::ROM::BASIC10;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
target->disk_interface = Target::DiskInterface::None;
|
|
|
|
// TODO: really this should add two targets if not all votes agree
|
|
if(basic11_votes >= basic10_votes || target->disk_interface == Target::DiskInterface::Microdisc)
|
|
target->rom = Target::ROM::BASIC11;
|
|
else
|
|
target->rom = Target::ROM::BASIC10;
|
|
|
|
TargetList targets;
|
|
if(target->media.tapes.size() || target->media.disks.size() || target->media.cartridges.size())
|
|
targets.push_back(std::move(target));
|
|
return targets;
|
|
}
|