+
+static int byteArrayReader(uint8_t *B, uint64_t A, void *Arg) {
+ ByteArrayTy &ByteArray = *((ByteArrayTy*)Arg);
+
+ if (A >= ByteArray.size())
+ return -1;
+
+ *B = ByteArray[A].first;
+
+ return 0;
+}
+
+static int verboseEvaluator(uint64_t *V, unsigned R, void *Arg) {
+ EDDisassembler &disassembler = *(EDDisassembler *)((void **)Arg)[0];
+ raw_ostream &Out = *(raw_ostream *)((void **)Arg)[1];
+
+ if (const char *regName = disassembler.nameWithRegisterID(R))
+ Out << "[" << regName << "/" << R << "]";
+
+ if (disassembler.registerIsStackPointer(R))
+ Out << "(sp)";
+ if (disassembler.registerIsProgramCounter(R))
+ Out << "(pc)";
+
+ *V = 0;
+ return 0;
+}
+
+int Disassembler::disassembleEnhanced(const std::string &TS,
+ MemoryBuffer &Buffer,
+ raw_ostream &Out) {
+ ByteArrayTy ByteArray;
+ StringRef Str = Buffer.getBuffer();
+ SourceMgr SM;
+
+ SM.AddNewSourceBuffer(&Buffer, SMLoc());
+
+ if (ByteArrayFromString(ByteArray, Str, SM)) {
+ return -1;
+ }
+
+ Triple T(TS);
+ EDDisassembler::AssemblySyntax AS;
+
+ switch (T.getArch()) {
+ default:
+ errs() << "error: no default assembly syntax for " << TS.c_str() << "\n";
+ return -1;
+ case Triple::arm:
+ case Triple::thumb:
+ AS = EDDisassembler::kEDAssemblySyntaxARMUAL;
+ break;
+ case Triple::x86:
+ case Triple::x86_64:
+ AS = EDDisassembler::kEDAssemblySyntaxX86ATT;
+ break;
+ }
+
+ OwningPtr<EDDisassembler>
+ disassembler(EDDisassembler::getDisassembler(TS.c_str(), AS));
+
+ if (disassembler == 0) {
+ errs() << "error: couldn't get disassembler for " << TS << '\n';
+ return -1;
+ }
+
+ while (ByteArray.size()) {
+ OwningPtr<EDInst>
+ inst(disassembler->createInst(byteArrayReader, 0, &ByteArray));
+
+ if (inst == 0) {
+ errs() << "error: Didn't get an instruction\n";
+ return -1;
+ }
+
+ ByteArray.erase (ByteArray.begin(), ByteArray.begin() + inst->byteSize());
+
+ unsigned numTokens = inst->numTokens();
+ if ((int)numTokens < 0) {
+ errs() << "error: couldn't count the instruction's tokens\n";
+ return -1;
+ }
+
+ for (unsigned tokenIndex = 0; tokenIndex != numTokens; ++tokenIndex) {
+ EDToken *token;
+
+ if (inst->getToken(token, tokenIndex)) {
+ errs() << "error: Couldn't get token\n";
+ return -1;
+ }
+
+ const char *buf;
+ if (token->getString(buf)) {
+ errs() << "error: Couldn't get string for token\n";
+ return -1;
+ }
+
+ Out << '[';
+ int operandIndex = token->operandID();
+
+ if (operandIndex >= 0)
+ Out << operandIndex << "-";
+
+ switch (token->type()) {
+ case EDToken::kTokenWhitespace: Out << "w"; break;
+ case EDToken::kTokenPunctuation: Out << "p"; break;
+ case EDToken::kTokenOpcode: Out << "o"; break;
+ case EDToken::kTokenLiteral: Out << "l"; break;
+ case EDToken::kTokenRegister: Out << "r"; break;
+ }
+
+ Out << ":" << buf;
+
+ if (token->type() == EDToken::kTokenLiteral) {
+ Out << "=";
+ if (token->literalSign())
+ Out << "-";
+ uint64_t absoluteValue;
+ if (token->literalAbsoluteValue(absoluteValue)) {
+ errs() << "error: Couldn't get the value of a literal token\n";
+ return -1;
+ }
+ Out << absoluteValue;
+ } else if (token->type() == EDToken::kTokenRegister) {
+ Out << "=";
+ unsigned regID;
+ if (token->registerID(regID)) {
+ errs() << "error: Couldn't get the ID of a register token\n";
+ return -1;
+ }
+ Out << "r" << regID;
+ }
+
+ Out << "]";
+ }
+
+ Out << " ";
+
+ if (inst->isBranch())
+ Out << "<br> ";
+ if (inst->isMove())
+ Out << "<mov> ";
+
+ unsigned numOperands = inst->numOperands();
+
+ if ((int)numOperands < 0) {
+ errs() << "error: Couldn't count operands\n";
+ return -1;
+ }
+
+ for (unsigned operandIndex = 0; operandIndex != numOperands;
+ ++operandIndex) {
+ Out << operandIndex << ":";
+
+ EDOperand *operand;
+ if (inst->getOperand(operand, operandIndex)) {
+ errs() << "error: couldn't get operand\n";
+ return -1;
+ }
+
+ uint64_t evaluatedResult;
+ void *Arg[] = { disassembler.get(), &Out };
+ if (operand->evaluate(evaluatedResult, verboseEvaluator, Arg)) {
+ errs() << "error: Couldn't evaluate an operand\n";
+ return -1;
+ }
+ Out << "=" << evaluatedResult << " ";
+ }
+
+ Out << '\n';
+ }
+
+ return 0;
+}
+