void MappingContextTraits<PdbTpiStream, pdb::yaml::SerializationContext>::mapping(
IO &IO, pdb::yaml::PdbTpiStream &Obj, pdb::yaml::SerializationContext &Context) {
IO.mapOptional("Version", Obj.Version, PdbTpiV80);
IO.mapRequired("Records", Obj.Records, Context);
}
void MappingTraits<MCModuleYAML::Function>::mapping(IO &IO,
MCModuleYAML::Function &F) {
IO.mapRequired("Name", F.Name);
IO.mapRequired("BasicBlocks", F.BasicBlocks);
}
void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,
ELFYAML::ELF_EF &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
#define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M)
switch (Object->Header.Machine) {
case ELF::EM_ARM:
BCase(EF_ARM_SOFT_FLOAT);
BCase(EF_ARM_VFP_FLOAT);
BCaseMask(EF_ARM_EABI_UNKNOWN, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER1, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER2, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER3, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER4, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER5, EF_ARM_EABIMASK);
break;
case ELF::EM_MIPS:
BCase(EF_MIPS_NOREORDER);
BCase(EF_MIPS_PIC);
BCase(EF_MIPS_CPIC);
BCase(EF_MIPS_ABI2);
BCase(EF_MIPS_32BITMODE);
BCase(EF_MIPS_FP64);
BCase(EF_MIPS_NAN2008);
BCase(EF_MIPS_MICROMIPS);
BCase(EF_MIPS_ARCH_ASE_M16);
BCase(EF_MIPS_ARCH_ASE_MDMX);
BCaseMask(EF_MIPS_ABI_O32, EF_MIPS_ABI);
BCaseMask(EF_MIPS_ABI_O64, EF_MIPS_ABI);
BCaseMask(EF_MIPS_ABI_EABI32, EF_MIPS_ABI);
BCaseMask(EF_MIPS_ABI_EABI64, EF_MIPS_ABI);
BCaseMask(EF_MIPS_MACH_3900, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4010, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4100, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4650, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4120, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4111, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_SB1, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_OCTEON, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_XLR, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_OCTEON2, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_OCTEON3, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_5400, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_5900, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_5500, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_9000, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_LS2E, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_LS2F, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_LS3A, EF_MIPS_MACH);
BCaseMask(EF_MIPS_ARCH_1, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_2, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_3, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_4, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_5, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_32, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_64, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_32R2, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_64R2, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_32R6, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_64R6, EF_MIPS_ARCH);
break;
case ELF::EM_HEXAGON:
BCase(EF_HEXAGON_MACH_V2);
BCase(EF_HEXAGON_MACH_V3);
BCase(EF_HEXAGON_MACH_V4);
BCase(EF_HEXAGON_MACH_V5);
BCase(EF_HEXAGON_ISA_V2);
BCase(EF_HEXAGON_ISA_V3);
BCase(EF_HEXAGON_ISA_V4);
BCase(EF_HEXAGON_ISA_V5);
break;
case ELF::EM_AVR:
BCase(EF_AVR_ARCH_AVR1);
BCase(EF_AVR_ARCH_AVR2);
BCase(EF_AVR_ARCH_AVR25);
BCase(EF_AVR_ARCH_AVR3);
BCase(EF_AVR_ARCH_AVR31);
BCase(EF_AVR_ARCH_AVR35);
BCase(EF_AVR_ARCH_AVR4);
BCase(EF_AVR_ARCH_AVR51);
BCase(EF_AVR_ARCH_AVR6);
BCase(EF_AVR_ARCH_AVRTINY);
BCase(EF_AVR_ARCH_XMEGA1);
BCase(EF_AVR_ARCH_XMEGA2);
BCase(EF_AVR_ARCH_XMEGA3);
BCase(EF_AVR_ARCH_XMEGA4);
BCase(EF_AVR_ARCH_XMEGA5);
BCase(EF_AVR_ARCH_XMEGA6);
BCase(EF_AVR_ARCH_XMEGA7);
break;
case ELF::EM_RISCV:
BCase(EF_RISCV_RVC);
BCaseMask(EF_RISCV_FLOAT_ABI_SOFT, EF_RISCV_FLOAT_ABI);
BCaseMask(EF_RISCV_FLOAT_ABI_SINGLE, EF_RISCV_FLOAT_ABI);
BCaseMask(EF_RISCV_FLOAT_ABI_DOUBLE, EF_RISCV_FLOAT_ABI);
BCaseMask(EF_RISCV_FLOAT_ABI_QUAD, EF_RISCV_FLOAT_ABI);
BCase(EF_RISCV_RVE);
break;
case ELF::EM_AMDGPU:
BCaseMask(EF_AMDGPU_MACH_NONE, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_R600, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_R630, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RS880, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV670, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV710, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV730, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV770, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CEDAR, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CYPRESS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_JUNIPER, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_REDWOOD, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_SUMO, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_BARTS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CAICOS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CAYMAN, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_TURKS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX600, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX601, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX700, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX701, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX702, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX703, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX704, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX801, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX802, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX803, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX810, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX900, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX902, EF_AMDGPU_MACH);
BCase(EF_AMDGPU_XNACK);
break;
case ELF::EM_X86_64:
break;
default:
llvm_unreachable("Unsupported architecture");
}
#undef BCase
#undef BCaseMask
}
void test_connect_pipe() {
IO* lhs = IO::allocate(state, G(io));
IO* rhs = IO::allocate(state, G(io));
TS_ASSERT(IO::connect_pipe(state, lhs, rhs)->true_p());
TS_ASSERT_EQUALS(Fixnum::from(0), lhs->lineno());
TS_ASSERT_EQUALS(Fixnum::from(0), rhs->lineno());
TS_ASSERT(kind_of<IOBuffer>(lhs->ibuffer()));
TS_ASSERT(kind_of<IOBuffer>(rhs->ibuffer()));
int acc_mode = fcntl(lhs->to_fd(), F_GETFL);
TS_ASSERT(acc_mode >= 0);
TS_ASSERT_EQUALS(Fixnum::from(acc_mode), lhs->mode());
acc_mode = fcntl(rhs->to_fd(), F_GETFL);
TS_ASSERT(acc_mode >= 0);
TS_ASSERT_EQUALS(Fixnum::from(acc_mode), rhs->mode());
lhs->close(state);
rhs->close(state);
}
void ScalarEnumerationTraits<MCAtom::AtomKind>::enumeration(
IO &IO, MCAtom::AtomKind &Value) {
IO.enumCase(Value, "Text", MCAtom::TextAtom);
IO.enumCase(Value, "Data", MCAtom::DataAtom);
}
static void mapping(IO &io, DataInCode &entry) {
io.mapRequired("offset", entry.offset);
io.mapRequired("length", entry.length);
io.mapRequired("kind", entry.kind);
}
int rb_io_fd(VALUE io_handle) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
IO* io = c_as<IO>(env->get_object(io_handle));
return io->descriptor()->to_native();
}
static void mapping(IO &Io, OpRec &Rec) {
Io.mapRequired("op", Rec.OpName);
Io.mapRequired("swift-args", Rec.SwiftArgs);
Io.mapRequired("op-args", Rec.OpArgs);
Io.mapRequired("file-map", Rec.FileMap);
}
static void mapping(IO &Io, std::pair<U, V> &Pair) {
Io.mapRequired("first", Pair.first);
Io.mapRequired("second", Pair.second);
}
static void enumeration(IO &io, llvm::pdb::PDB_Machine &Value) {
io.enumCase(Value, "Invalid", PDB_Machine::Invalid);
io.enumCase(Value, "Am33", PDB_Machine::Am33);
io.enumCase(Value, "Amd64", PDB_Machine::Amd64);
io.enumCase(Value, "Arm", PDB_Machine::Arm);
io.enumCase(Value, "ArmNT", PDB_Machine::ArmNT);
io.enumCase(Value, "Ebc", PDB_Machine::Ebc);
io.enumCase(Value, "x86", PDB_Machine::x86);
io.enumCase(Value, "Ia64", PDB_Machine::Ia64);
io.enumCase(Value, "M32R", PDB_Machine::M32R);
io.enumCase(Value, "Mips16", PDB_Machine::Mips16);
io.enumCase(Value, "MipsFpu", PDB_Machine::MipsFpu);
io.enumCase(Value, "MipsFpu16", PDB_Machine::MipsFpu16);
io.enumCase(Value, "PowerPCFP", PDB_Machine::PowerPCFP);
io.enumCase(Value, "R4000", PDB_Machine::R4000);
io.enumCase(Value, "SH3", PDB_Machine::SH3);
io.enumCase(Value, "SH3DSP", PDB_Machine::SH3DSP);
io.enumCase(Value, "Thumb", PDB_Machine::Thumb);
io.enumCase(Value, "WceMipsV2", PDB_Machine::WceMipsV2);
}
int main(int argv, char** argc)
{
if (parseArgs(argv, argc)){
return Config::EXIT_NORMAL;
}
Util::init();
string key = entry();
if (key.empty()){
printc("no key provided!\n", ANSI_RED);
print("run cle --help for more information\n");
return Config::EXIT_NO_ENTRY;
}
printc("cle " + Config::vn + "\n", ANSI_BLUE);
if (verbose()){
print("opening entry " + entry() + "\n");
}
Util::hideText();
print("enter passphrase > ");
string pass = IO::readPass();
Util::showText();
print();
unsigned char* hash = new unsigned char[32];
Util::fileHash((pass + key).c_str(), pass.size() + key.size(), hash);
string path = Util::hexstr(hash, 32);
if (verbose()){
print("key hash:\n");
print(path + "\n");
}
auto file = IO::readFile(path);
if (file.fail()){
print("key does not exist under passphrase.\n");
if (IO::prompt("create it? [Y/n] > ") == "Y"){
IO::newKey(path);
Crypt crypt(const_cast<char*>(pass.c_str()), pass.size());
crypt.encrypt(path, path);
} else{
print("not creating key.\n");
}
} else{
printc("entry for " + key + "\n\n", ANSI_BLUE);
unsigned char* salt = Util::readSalt(path);
Crypt crypt(const_cast<char*>(pass.c_str()), pass.size(), salt);
crypt.decrypt(path, path);
}
return Config::EXIT_NORMAL;
}
void MappingContextTraits<PdbInlineeInfo, SerializationContext>::mapping(
IO &IO, PdbInlineeInfo &Obj, SerializationContext &Context) {
IO.mapRequired("HasExtraFiles", Obj.HasExtraFiles);
IO.mapRequired("Sites", Obj.Sites, Context);
}
void MappingContextTraits<PdbModiStream, pdb::yaml::SerializationContext>::mapping(IO &IO, PdbModiStream &Obj, pdb::yaml::SerializationContext &Context) {
IO.mapOptional("Signature", Obj.Signature, 4U);
IO.mapRequired("Records", Obj.Symbols, Context);
}
void MappingTraits<NamedStreamMapping>::mapping(IO &IO,
NamedStreamMapping &Obj) {
IO.mapRequired("Name", Obj.StreamName);
IO.mapRequired("StreamNum", Obj.StreamNumber);
}
static void mapping(IO &io, Segment& seg) {
io.mapRequired("name", seg.name);
io.mapRequired("address", seg.address);
io.mapRequired("size", seg.size);
io.mapRequired("access", seg.access);
}
bool XMLRW::ReadXml(char *XmlFile)
{
// 定义一个TiXmlDocument类指针
TiXmlDocument *pDoc = new TiXmlDocument(XmlFile);
if (NULL==pDoc)
{
return false;
}
pDoc->LoadFile(TIXML_ENCODING_UTF8);
TiXmlElement *pRootEle = pDoc->RootElement();
if (NULL==pRootEle)
{
return false;
}
pDlgBlackInout->GetDlgItem(IDC_STATIC_INFO)->SetWindowText("已读取: 0 条");
char temp[XMLRW_MAX_STR];
struct BLACK_DATA_ST data={0};
TiXmlElement *pNodeRow = NULL;
TiXmlElement *pNodeData = NULL;
unsigned long int i=1;
for(pNodeRow = pRootEle; pNodeRow; pNodeRow = pNodeRow->NextSiblingElement())
{
memset(&data,0,sizeof(struct BLACK_DATA_ST));
//获取信息
if(ReadQueryNodeText(pNodeRow,pNodeRow,"ROW",temp))
{
pNodeData = NULL;
ReadQueryNodeText(pNodeRow,pNodeData,"SCARNUMBER",data.plate);
pNodeData = NULL;
ReadQueryNodeText(pNodeRow,pNodeData,"SBRAND",data.brand);
pNodeData = NULL;
ReadQueryNodeText(pNodeRow,pNodeData,"SLOSTNAME",data.name);
pNodeData = NULL;
ReadQueryNodeText(pNodeRow,pNodeData,"SPHONE",data.Phone);
pNodeData = NULL;
ReadQueryNodeText(pNodeRow,pNodeData,"SMARK",data.other);
//车牌号为空
if(0==strlen(data.plate))
continue ;
//写入一条
#if ALLTAB_DETECT_CAR_MODE
//汽车
if(OracleIO.CAR_BlackTable_AddNew(data))
#else
//电动车
if(OracleIO.ELECAR_BlackTable_AddNew(data))
#endif
{
pDlgBlackInout->m_info.Format("已导入: %d 条",i);
pDlgBlackInout->GetDlgItem(IDC_STATIC_INFO)->SetWindowText(pDlgBlackInout->m_info);
i++;
}
}
}
return true;
}
static void mapping(IO &io, RebaseLocation& rebase) {
io.mapRequired("segment-index", rebase.segIndex);
io.mapRequired("segment-offset", rebase.segOffset);
io.mapOptional("kind", rebase.kind,
llvm::MachO::REBASE_TYPE_POINTER);
}
void test_connect_pipe() {
IO* lhs = IO::allocate(state, G(io));
IO* rhs = IO::allocate(state, G(io));
TS_ASSERT(IO::connect_pipe(state, lhs, rhs)->true_p());
TS_ASSERT_EQUALS(Fixnum::from(0), lhs->lineno());
TS_ASSERT_EQUALS(Fixnum::from(0), rhs->lineno());
TS_ASSERT(kind_of<IOBuffer>(lhs->ibuffer()));
TS_ASSERT(kind_of<IOBuffer>(rhs->ibuffer()));
TS_ASSERT_EQUALS(Fixnum::from(O_RDONLY), lhs->mode());
TS_ASSERT_EQUALS(Fixnum::from(O_WRONLY), rhs->mode());
rhs->write(state, String::create(state, "hello"), 0);
Object* obj = lhs->blocking_read(state, Fixnum::from(5));
TS_ASSERT(kind_of<String>(obj));
String* str = try_as<String>(obj);
TS_ASSERT_EQUALS(std::string("hello"), str->c_str());
lhs->close(state);
rhs->close(state);
}
void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
IO.mapRequired("FileHeader", Object.Header);
IO.mapOptional("Sections", Object.Sections);
IO.mapOptional("Symbols", Object.Symbols);
}
static void enumeration(IO &io, HeaderFileType &value) {
io.enumCase(value, "MH_OBJECT", llvm::MachO::MH_OBJECT);
io.enumCase(value, "MH_DYLIB", llvm::MachO::MH_DYLIB);
io.enumCase(value, "MH_EXECUTE", llvm::MachO::MH_EXECUTE);
io.enumCase(value, "MH_BUNDLE", llvm::MachO::MH_BUNDLE);
}
int main()
#endif
// int main () // Linux users should use this line instead the previous one
{
clock_t start;
start = clock();
int linesWon = 0;
ofstream output("testBLEE.txt");
// ----- Vars -----
// Class for drawing staff, it uses SDL for the rendering. Change the methods of this class
// in order to use a different renderer
IO mIO;
int mScreenHeight = mIO.GetScreenHeight();
// Pieces
Pieces mPieces;
// Board
Board mBoard = Board (&mPieces, mScreenHeight);
// Game
Game mGame (&mBoard, &mPieces, &mIO, mScreenHeight);
// Get the actual clock milliseconds (SDL)
unsigned long mTime1 = SDL_GetTicks() + 630;
// ----- Main Loop -----
while (!mIO.IsKeyDown (SDLK_ESCAPE))
{
// ----- Draw -----
mIO.ClearScreen (); // Clear screen
mGame.DrawScene (); // Draw staff
mIO.UpdateScreen (); // Put the graphic context in the screen
// ----- Input -----
int mKey = mIO.Pollkey();
switch (mKey)
{
case (SDLK_RIGHT):
{
if (mBoard.IsPossibleMovement (mGame.mPosX + 1, mGame.mPosY, mGame.mPiece, mGame.mRotation))
mGame.mPosX++;
break;
}
case (SDLK_LEFT):
{
if (mBoard.IsPossibleMovement (mGame.mPosX - 1, mGame.mPosY, mGame.mPiece, mGame.mRotation))
mGame.mPosX--;
break;
}
case (SDLK_DOWN):
{
if (mBoard.IsPossibleMovement (mGame.mPosX, mGame.mPosY + 1, mGame.mPiece, mGame.mRotation))
mGame.mPosY++;
break;
}
case (SDLK_x):
{
// Check collision from up to down
while (mBoard.IsPossibleMovement(mGame.mPosX, mGame.mPosY, mGame.mPiece, mGame.mRotation)) { mGame.mPosY++; }
mBoard.StorePiece (mGame.mPosX, mGame.mPosY - 1, mGame.mPiece, mGame.mRotation);
linesWon += mBoard.DeletePossibleLines ();
if (mBoard.IsGameOver())
{
output << linesWon << endl;
output <<(clock() - start)/ (double)CLOCKS_PER_SEC << endl;
mIO.Getkey();
exit(0);
}
mGame.CreateNewPiece();
break;
}
case (SDLK_z):
{
if (mBoard.IsPossibleMovement (mGame.mPosX, mGame.mPosY, mGame.mPiece, (mGame.mRotation + 1) % 4))
mGame.mRotation = (mGame.mRotation + 1) % 4;
break;
}
}
// ----- Vertical movement -----
unsigned long mTime2 = SDL_GetTicks() ;//+ 630;
if ((mTime2 - mTime1) > WAIT_TIME)
{
if (mBoard.IsPossibleMovement (mGame.mPosX, mGame.mPosY + 1, mGame.mPiece, mGame.mRotation))
{
mGame.mPosY++;
}
else
{
mBoard.StorePiece (mGame.mPosX, mGame.mPosY, mGame.mPiece, mGame.mRotation);
mBoard.DeletePossibleLines ();
if (mBoard.IsGameOver())
{
mIO.Getkey();
exit(0);
}
mGame.CreateNewPiece();
}
mTime1 = SDL_GetTicks();
}
}
return 0;
}
static void bitset(IO &io, FileFlags &value) {
io.bitSetCase(value, "MH_TWOLEVEL",
llvm::MachO::MH_TWOLEVEL);
io.bitSetCase(value, "MH_SUBSECTIONS_VIA_SYMBOLS",
llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
}
static void enumeration(IO &inputOutput, TriState &value)
{
inputOutput.enumCase(value, "true", TriState::TRUE);
inputOutput.enumCase(value, "false", TriState::FALSE);
}
static void enumeration(IO &io, SectionType &value) {
io.enumCase(value, "S_REGULAR",
llvm::MachO::S_REGULAR);
io.enumCase(value, "S_ZEROFILL",
llvm::MachO::S_ZEROFILL);
io.enumCase(value, "S_CSTRING_LITERALS",
llvm::MachO::S_CSTRING_LITERALS);
io.enumCase(value, "S_4BYTE_LITERALS",
llvm::MachO::S_4BYTE_LITERALS);
io.enumCase(value, "S_8BYTE_LITERALS",
llvm::MachO::S_8BYTE_LITERALS);
io.enumCase(value, "S_LITERAL_POINTERS",
llvm::MachO::S_LITERAL_POINTERS);
io.enumCase(value, "S_NON_LAZY_SYMBOL_POINTERS",
llvm::MachO::S_NON_LAZY_SYMBOL_POINTERS);
io.enumCase(value, "S_LAZY_SYMBOL_POINTERS",
llvm::MachO::S_LAZY_SYMBOL_POINTERS);
io.enumCase(value, "S_SYMBOL_STUBS",
llvm::MachO::S_SYMBOL_STUBS);
io.enumCase(value, "S_MOD_INIT_FUNC_POINTERS",
llvm::MachO::S_MOD_INIT_FUNC_POINTERS);
io.enumCase(value, "S_MOD_TERM_FUNC_POINTERS",
llvm::MachO::S_MOD_TERM_FUNC_POINTERS);
io.enumCase(value, "S_COALESCED",
llvm::MachO::S_COALESCED);
io.enumCase(value, "S_GB_ZEROFILL",
llvm::MachO::S_GB_ZEROFILL);
io.enumCase(value, "S_INTERPOSING",
llvm::MachO::S_INTERPOSING);
io.enumCase(value, "S_16BYTE_LITERALS",
llvm::MachO::S_16BYTE_LITERALS);
io.enumCase(value, "S_DTRACE_DOF",
llvm::MachO::S_DTRACE_DOF);
io.enumCase(value, "S_LAZY_DYLIB_SYMBOL_POINTERS",
llvm::MachO::S_LAZY_DYLIB_SYMBOL_POINTERS);
io.enumCase(value, "S_THREAD_LOCAL_REGULAR",
llvm::MachO::S_THREAD_LOCAL_REGULAR);
io.enumCase(value, "S_THREAD_LOCAL_ZEROFILL",
llvm::MachO::S_THREAD_LOCAL_ZEROFILL);
io.enumCase(value, "S_THREAD_LOCAL_VARIABLES",
llvm::MachO::S_THREAD_LOCAL_VARIABLES);
io.enumCase(value, "S_THREAD_LOCAL_VARIABLE_POINTERS",
llvm::MachO::S_THREAD_LOCAL_VARIABLE_POINTERS);
io.enumCase(value, "S_THREAD_LOCAL_INIT_FUNCTION_POINTERS",
llvm::MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS);
}
void MappingTraits<MCModuleYAML::Inst>::mapping(IO &IO, MCModuleYAML::Inst &I) {
IO.mapRequired("Inst", I.Opcode);
IO.mapRequired("Size", I.Size);
IO.mapRequired("Ops", I.Operands);
}
static void bitset(IO &io, SymbolScope &value) {
io.bitSetCase(value, "N_EXT", llvm::MachO::N_EXT);
io.bitSetCase(value, "N_PEXT", llvm::MachO::N_PEXT);
}
void MappingTraits<MCModuleYAML::Module>::mapping(IO &IO,
MCModuleYAML::Module &M) {
IO.mapRequired("Atoms", M.Atoms);
IO.mapOptional("Functions", M.Functions);
}
static void enumeration(IO &io, RelocationInfoType &value) {
YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
assert(info != nullptr);
NormalizedFile *file = info->_normalizeMachOFile;
assert(file != nullptr);
switch (file->arch) {
case lld::MachOLinkingContext::arch_x86_64:
io.enumCase(value, "X86_64_RELOC_UNSIGNED",
llvm::MachO::X86_64_RELOC_UNSIGNED);
io.enumCase(value, "X86_64_RELOC_SIGNED",
llvm::MachO::X86_64_RELOC_SIGNED);
io.enumCase(value, "X86_64_RELOC_BRANCH",
llvm::MachO::X86_64_RELOC_BRANCH);
io.enumCase(value, "X86_64_RELOC_GOT_LOAD",
llvm::MachO::X86_64_RELOC_GOT_LOAD);
io.enumCase(value, "X86_64_RELOC_GOT",
llvm::MachO::X86_64_RELOC_GOT);
io.enumCase(value, "X86_64_RELOC_SUBTRACTOR",
llvm::MachO::X86_64_RELOC_SUBTRACTOR);
io.enumCase(value, "X86_64_RELOC_SIGNED_1",
llvm::MachO::X86_64_RELOC_SIGNED_1);
io.enumCase(value, "X86_64_RELOC_SIGNED_2",
llvm::MachO::X86_64_RELOC_SIGNED_2);
io.enumCase(value, "X86_64_RELOC_SIGNED_4",
llvm::MachO::X86_64_RELOC_SIGNED_4);
io.enumCase(value, "X86_64_RELOC_TLV",
llvm::MachO::X86_64_RELOC_TLV);
break;
case lld::MachOLinkingContext::arch_x86:
io.enumCase(value, "GENERIC_RELOC_VANILLA",
llvm::MachO::GENERIC_RELOC_VANILLA);
io.enumCase(value, "GENERIC_RELOC_PAIR",
llvm::MachO::GENERIC_RELOC_PAIR);
io.enumCase(value, "GENERIC_RELOC_SECTDIFF",
llvm::MachO::GENERIC_RELOC_SECTDIFF);
io.enumCase(value, "GENERIC_RELOC_LOCAL_SECTDIFF",
llvm::MachO::GENERIC_RELOC_LOCAL_SECTDIFF);
io.enumCase(value, "GENERIC_RELOC_TLV",
llvm::MachO::GENERIC_RELOC_TLV);
break;
case lld::MachOLinkingContext::arch_armv6:
case lld::MachOLinkingContext::arch_armv7:
case lld::MachOLinkingContext::arch_armv7s:
io.enumCase(value, "ARM_RELOC_VANILLA",
llvm::MachO::ARM_RELOC_VANILLA);
io.enumCase(value, "ARM_RELOC_PAIR",
llvm::MachO::ARM_RELOC_PAIR);
io.enumCase(value, "ARM_RELOC_SECTDIFF",
llvm::MachO::ARM_RELOC_SECTDIFF);
io.enumCase(value, "ARM_RELOC_LOCAL_SECTDIFF",
llvm::MachO::ARM_RELOC_LOCAL_SECTDIFF);
io.enumCase(value, "ARM_RELOC_BR24",
llvm::MachO::ARM_RELOC_BR24);
io.enumCase(value, "ARM_THUMB_RELOC_BR22",
llvm::MachO::ARM_THUMB_RELOC_BR22);
io.enumCase(value, "ARM_RELOC_HALF",
llvm::MachO::ARM_RELOC_HALF);
io.enumCase(value, "ARM_RELOC_HALF_SECTDIFF",
llvm::MachO::ARM_RELOC_HALF_SECTDIFF);
break;
case lld::MachOLinkingContext::arch_arm64:
io.enumCase(value, "ARM64_RELOC_UNSIGNED",
llvm::MachO::ARM64_RELOC_UNSIGNED);
io.enumCase(value, "ARM64_RELOC_SUBTRACTOR",
llvm::MachO::ARM64_RELOC_SUBTRACTOR);
io.enumCase(value, "ARM64_RELOC_BRANCH26",
llvm::MachO::ARM64_RELOC_BRANCH26);
io.enumCase(value, "ARM64_RELOC_PAGE21",
llvm::MachO::ARM64_RELOC_PAGE21);
io.enumCase(value, "ARM64_RELOC_PAGEOFF12",
llvm::MachO::ARM64_RELOC_PAGEOFF12);
io.enumCase(value, "ARM64_RELOC_GOT_LOAD_PAGE21",
llvm::MachO::ARM64_RELOC_GOT_LOAD_PAGE21);
io.enumCase(value, "ARM64_RELOC_GOT_LOAD_PAGEOFF12",
llvm::MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12);
io.enumCase(value, "ARM64_RELOC_POINTER_TO_GOT",
llvm::MachO::ARM64_RELOC_POINTER_TO_GOT);
io.enumCase(value, "ARM64_RELOC_TLVP_LOAD_PAGE21",
llvm::MachO::ARM64_RELOC_TLVP_LOAD_PAGE21);
io.enumCase(value, "ARM64_RELOC_TLVP_LOAD_PAGEOFF12",
llvm::MachO::ARM64_RELOC_TLVP_LOAD_PAGEOFF12);
io.enumCase(value, "ARM64_RELOC_ADDEND",
llvm::MachO::ARM64_RELOC_ADDEND);
break;
default:
llvm_unreachable("unknown architecture");
}
}
void MappingTraits<ELFYAML::LocalGlobalWeakSymbols>::mapping(
IO &IO, ELFYAML::LocalGlobalWeakSymbols &Symbols) {
IO.mapOptional("Local", Symbols.Local);
IO.mapOptional("Global", Symbols.Global);
IO.mapOptional("Weak", Symbols.Weak);
}
void MappingTraits<StreamBlockList>::mapping(IO &IO, StreamBlockList &SB) {
IO.mapRequired("Stream", SB.Blocks);
}
