This is an archive of the discontinued LLVM Phabricator instance.

Differential D52341

[mctoll] Initial changes for MC to LL raiser that takes a binary and raises it back to llvm bitcode
AbandonedPublic

Authored by asmith on Sep 20 2018, 10:33 PM.

Details

Reviewers
llvm-commits
javed.absar
Summary

This is the initial set of changes for a new tool called llvm-mctoll that raises binaries back to llvm bitcode. Currently there is support for raising Arm32 and x64 Linux elf shared libraries and simple executables such as dhrystone.

Here is a summary of features in varying states of completion:

  1. Function boundary identification. Analyzes the text section of an elf input binary (executable or shared library) to identify function boundaries.
  1. CFG construction. Builds the CFG for a function and the corresponding MachineFunction representation along with the constituent MachineBlocks. The MachineFunction object is used to materialize a Function object by raising the instructions of MachineBlock into BasicBlocks of the Function object.
  1. Instruction raising. Stack accesses are abstracted to alloca instructions. Various abstract instruction classes are defined - such as memory referencing instructions, floating point instructions, register move instructions, binary operator instructions, etc.
  1. Function prototype discovery. A MachineFunction is analyzed to create an abstract function prototype. The current implementation assumes that the binaries are 64-bit and are compiled from C sources. The function prototype discovery algorithm assumes C calling-conventions and is limited to arguments passed on the stack ( > 6 args is not implemented yet). Calls to variadic functions are discovered by analyzing the instructions. Linkage to external functions (such as to glibc) is handled by maintaining a table of known function signatures.
  1. Information from various sections of the ELF binary - such as GOT, PLT, data sections and symbol table is used to materialize materialize machine-independent abstractions such as string constants, external call linkage etc.
  1. There are tests that try to cover much of the major functionality for both Arm32 and x64.

Diff Detail

Repository
rL LLVM

Event Timeline

asmith created this revision.Sep 20 2018, 10:33 PM
Herald added a reviewer: javed.absar. · View Herald TranscriptSep 20 2018, 10:33 PM
Herald added subscribers: jfb, mgrang, aheejin and 3 others. · View Herald Transcript
kristof.beyls added a comment.Sep 21 2018, 12:14 AM

Hi Aaron,

Thanks for sharing - this looks like an interesting tool.
Having scrolled real quickly through the code, I'm assuming that as is, this is the version of the tool as you created more or less out-of-tree?
Or in other words, a bit of polish probably is needed to get it integrated better - e.g.

  • is the LICENSE.TXT file necessary?
  • Some of the testing seems to require quite a lot of things to be enabled in the build - so maybe that needs refinement?
  • Do we really want to build and run (pristine?) dhrystone as part of testing?

However, I'm assuming those are just details at the moment.
I think it may be good to kick of a thread on llvm-dev about introducing this tool. I'm assuming that'll increase visibility, reaching more people who have built similar tools in the past.
Not being an expert in this area, I wonder about:

  1. Intended use cases for this tool.
  2. What are the expected limitations, both now (because of current implementation status) and in the future (theoretical limitations based on design)?

Thanks!

Kristof

bharadwajy added a subscriber: bharadwajy.Sep 21 2018, 10:01 AM
bharadwajy added a comment.Sep 21 2018, 10:09 AM
In D52341#1241471, @kristof.beyls wrote:

Hi Aaron,

Thanks for sharing - this looks like an interesting tool.
Having scrolled real quickly through the code, I'm assuming that as is, this is the version of the tool as you created more or less out-of-tree?

...

Hi Kristof,

The tool is set up to build in-tree - similar to others in the tools directory. There are remnants in llvm-mctoll/CMakeLists.txt of an earlier support to build out-of-tree. I can clean it up.

Thanks,

Bharadwaj

Matt added a subscriber: Matt.Oct 11 2018, 8:50 PM
asmith abandoned this revision.Oct 16 2018, 9:33 PM

We've setup a github repo and can continue the discussion there.

https://github.com/Microsoft/llvm-mctoll

Revision Contents

PathSize
tools/
llvm-mctoll/
ARM/
42 lines
361 lines
47 lines
224 lines
39 lines
86 lines
57 lines
18 lines
117 lines
728 lines
105 lines
48 lines
46 lines
40 lines
89 lines
68 lines
22 lines
34 lines
46 lines
84 lines
146 lines
244 lines
9596 lines
75 lines
303 lines
80 lines
155 lines
101 lines
28 lines
X86/
16 lines
14636 lines
162 lines
4091 lines
108 lines
2137 lines
test/
31 lines
dhrystone/
9 lines
431 lines
40 lines
337 lines
291 lines
1 line
48 lines
23 lines
smoke_test/
Inputs/
6 lines
7 lines
7 lines
3 lines
16 lines
5 lines
8 lines
5 lines
14 lines
14 lines
19 lines
11 lines
1 line
23 lines
46 lines
14 lines
14 lines
14 lines
18 lines
unittests/
ARM/
FunctionPrototype/
1 line
9 lines
PrologEpilog/
1 line
25 lines
32 lines
21 lines
25 lines
30 lines
ARMInstrs/
20 lines
19 lines
7 lines
225 lines

Diff 166402

tools/llvm-mctoll/ARM/ARMEliminatePrologEpilog.h

  • This file was added.
//===--- ARMEliminatePrologEpilog.h - Binary raiser utility llvm-mctoll ---===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of ARMEliminatePrologEpilog class for
// use by llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMELIMINATEPROLOGEPILOG_H
#define LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMELIMINATEPROLOGEPILOG_H
#include "ARMRaiserBase.h"
using namespace llvm;
class ARMEliminatePrologEpilog : public ARMRaiserBase {
public:
static char ID;
ARMEliminatePrologEpilog(ModuleRaiser &mr);
~ARMEliminatePrologEpilog();
void init(MachineFunction *mf = nullptr, Function *rf = nullptr) override;
bool eliminate();
bool runOnMachineFunction(MachineFunction &mf) override;
private:
bool checkRegister(unsigned Reg, std::vector<MachineInstr *> &instrs) const;
bool eliminateProlog(MachineFunction &mf) const;
bool eliminateEpilog(MachineFunction &mf) const;
/// Analyze stack size base on moving sp.
void analyzeStackSize(MachineFunction &mf);
/// Analyze frame adjustment base on the offset between fp and base sp.
void analyzeFrameAdjustment(MachineFunction &mf);
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMELIMINATEPROLOGEPILOG_H

tools/llvm-mctoll/ARM/ARMEliminatePrologEpilog.cpp

  • This file was added.
//===- ARMEliminatePrologEpilog.cpp - Binary raiser utility llvm-mctoll -===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the implementation of ARMEliminatePrologEpilog class
// for use by llvm-mctoll.
//
//===----------------------------------------------------------------------===/
#include "ARMEliminatePrologEpilog.h"
#include "ARMSubtarget.h"
using namespace llvm;
char ARMEliminatePrologEpilog::ID = 0;
ARMEliminatePrologEpilog::ARMEliminatePrologEpilog(ModuleRaiser &mr)
: ARMRaiserBase(ID, mr) {}
ARMEliminatePrologEpilog::~ARMEliminatePrologEpilog() {}
void ARMEliminatePrologEpilog::init(MachineFunction *mf, Function *rf) {
ARMRaiserBase::init(mf, rf);
}
// Return true if an operand in the instrs vector matches the passed register
// number, otherwise false.
bool ARMEliminatePrologEpilog::checkRegister(
unsigned Reg, std::vector<MachineInstr *> &instrs) const {
std::vector<MachineInstr *>::iterator it = instrs.begin();
for (; it < instrs.end(); ++it) {
MachineInstr *mi = *it;
if (mi->mayStore()) {
for (unsigned i = 0; i < mi->getNumOperands(); i++) {
MachineOperand MO = mi->getOperand(i);
// Compare the register number.
if (MO.isReg() && MO.getReg() == Reg)
return true;
}
}
}
return false;
}
// Raise the function prolog.
//
// Look for the following instructions and eliminate them:
// str fp, [sp, #-4]!
// add fp, sp, #0
//
// sub sp, fp, #0
// ldr fp, [sp], #4
// AND
// push {r11,lr}
// add r11, sp, #4
//
// sub sp, r11, #4
// pop {r11, pc}
// AND
// stmdb r13!, {r0-r3}
// stmdb r13!, {r4-r12,r13,r14}
//
// ldmia r13, {r4-r11, r13, r15}
// AND
// mov r12, r13
// stmdb r13!, {r0-r3}
// stmdb r13!, {r4-r12, r14}
// sub r11, r12, #16
//
// ldmdb r13, {r4-r11, r13, r15}
bool ARMEliminatePrologEpilog::eliminateProlog(MachineFunction &MF) const {
std::vector<MachineInstr *> prologInstrs;
MachineBasicBlock &frontMBB = MF.front();
const ARMSubtarget &STI = MF.getSubtarget<ARMSubtarget>();
const ARMBaseRegisterInfo *RegInfo = STI.getRegisterInfo();
unsigned FramePtr = RegInfo->getFrameRegister(MF);
for (MachineBasicBlock::iterator frontMBBIter = frontMBB.begin();
frontMBBIter != frontMBB.end(); frontMBBIter++) {
MachineInstr &curMachInstr = (*frontMBBIter);
// Push the MOVr instruction
if (curMachInstr.getOpcode() == ARM::MOVr) {
if ((curMachInstr.getOperand(1).isReg() &&
curMachInstr.getOperand(1).getReg() == FramePtr))
prologInstrs.push_back(&curMachInstr);
}
// Push the STORE instruction
if (curMachInstr.mayStore()) {
MachineOperand storeOperand = curMachInstr.getOperand(0);
if (storeOperand.isReg() && storeOperand.getReg() == FramePtr) {
prologInstrs.push_back(&curMachInstr);
}
}
// Push the ADDri instruction
if (curMachInstr.getOpcode() == ARM::ADDri &&
curMachInstr.getOperand(1).getReg() == FramePtr) {
prologInstrs.push_back(&curMachInstr);
}
// Push the SUBri instruction
if (curMachInstr.getOpcode() == ARM::SUBri &&
curMachInstr.getOperand(0).getReg() == FramePtr &&
curMachInstr.getOperand(1).getReg() == FramePtr) {
prologInstrs.push_back(&curMachInstr);
}
// Push sub r11, r12, #16
if (curMachInstr.getOpcode() == ARM::SUBri &&
curMachInstr.getOperand(0).getReg() == ARM::R11 &&
curMachInstr.getOperand(1).getReg() == ARM::R12) {
prologInstrs.push_back(&curMachInstr);
}
}
// Create the stack frame
const TargetRegisterInfo *TRI = MF.getRegInfo().getTargetRegisterInfo();
const MCPhysReg *CSRegs = TRI->getCalleeSavedRegs(&MF);
std::vector<CalleeSavedInfo> CSI;
for (unsigned i = 0; CSRegs[i]; ++i) {
unsigned Reg = CSRegs[i];
// Save register.
if (checkRegister(Reg, prologInstrs)) {
CSI.push_back(CalleeSavedInfo(Reg));
}
}
const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
MachineFrameInfo &MFI = MF.getFrameInfo();
if (!TFI->assignCalleeSavedSpillSlots(MF, RegInfo, CSI)) {
// If target doesn't implement this, use generic code.
if (CSI.empty())
return true; // Early exit if no callee saved registers are modified!
unsigned NumFixedSpillSlots;
const TargetFrameLowering::SpillSlot *FixedSpillSlots =
TFI->getCalleeSavedSpillSlots(NumFixedSpillSlots);
// Allocate stack slots for the registers that need to be saved and restored
unsigned Offset = 0;
for (auto &CS : CSI) {
unsigned Reg = CS.getReg();
const TargetRegisterClass *RC = RegInfo->getMinimalPhysRegClass(Reg);
int FrameIdx;
if (RegInfo->hasReservedSpillSlot(MF, Reg, FrameIdx)) {
CS.setFrameIdx(FrameIdx);
continue;
}
// Check if this physreg must be spilled to a particular stack slot for
// this target
const TargetFrameLowering::SpillSlot *FixedSlot = FixedSpillSlots;
while (FixedSlot != FixedSpillSlots + NumFixedSpillSlots &&
FixedSlot->Reg != Reg)
++FixedSlot;
unsigned Size = RegInfo->getSpillSize(*RC);
if (FixedSlot == FixedSpillSlots + NumFixedSpillSlots) {
// Nope, just spill it anywhere convenient.
unsigned Align = RegInfo->getSpillAlignment(*RC);
unsigned StackAlign = TFI->getStackAlignment();
// The alignment is the minimum of the desired alignment of the
// TargetRegisterClass and the stack alignment, whichever is smaller.
Align = std::min(Align, StackAlign);
FrameIdx = MFI.CreateStackObject(Size, Align, true);
Offset += Size;
// Set the object offset
MFI.setObjectOffset(FrameIdx, MFI.getObjectOffset(FrameIdx) - Offset);
} else {
// Spill to the stack.
FrameIdx = MFI.CreateFixedSpillStackObject(Size, FixedSlot->Offset);
}
// Set the frame index
CS.setFrameIdx(FrameIdx);
}
MFI.setCalleeSavedInfo(CSI);
}
// Eliminate the instructions identified in function prologue
unsigned int delInstSz = prologInstrs.size();
for (unsigned int i = 0; i < delInstSz; i++) {
frontMBB.erase(prologInstrs[i]);
}
return true;
}
bool ARMEliminatePrologEpilog::eliminateEpilog(MachineFunction &MF) const {
const ARMSubtarget &STI = MF.getSubtarget<ARMSubtarget>();
const ARMBaseRegisterInfo *RegInfo = STI.getRegisterInfo();
const ARMBaseInstrInfo *TII = STI.getInstrInfo();
unsigned FramePtr = RegInfo->getFrameRegister(MF);
for (MachineBasicBlock &MBB : MF) {
std::vector<MachineInstr *> epilogInstrs;
// MBBI may be invalidated by the raising operation.
for (MachineBasicBlock::iterator backMBBIter = MBB.begin();
backMBBIter != MBB.end(); backMBBIter++) {
MachineInstr &curMachInstr = (*backMBBIter);
// Push the LOAD instruction
if (curMachInstr.mayLoad()) {
MachineOperand loadOperand = curMachInstr.getOperand(0);
if (loadOperand.isReg() && loadOperand.getReg() == FramePtr) {
// If the register list of current POP includes PC register,
// it should be replaced with return instead of removed.
if (curMachInstr.findRegisterUseOperandIdx(ARM::PC) != -1) {
MachineInstrBuilder mib =
BuildMI(MBB, &curMachInstr, DebugLoc(), TII->get(ARM::BX_RET));
int cpsridx = curMachInstr.findRegisterUseOperandIdx(ARM::CPSR);
if (cpsridx == -1) {
mib.addImm(14);
} else {
mib.add(curMachInstr.getOperand(cpsridx - 1))
.add(curMachInstr.getOperand(cpsridx));
}
mib.add(curMachInstr.getOperand(
curMachInstr.getNumExplicitOperands() - 1));
}
epilogInstrs.push_back(&curMachInstr);
}
}
// Push the LDR instruction
if (curMachInstr.getOpcode() == ARM::LDR_POST_IMM &&
curMachInstr.getOperand(1).getReg() == FramePtr) {
epilogInstrs.push_back(&curMachInstr);
}
// Push the STR instruction
if (curMachInstr.getOpcode() == ARM::STR_PRE_IMM &&
curMachInstr.getOperand(0).getReg() == FramePtr) {
epilogInstrs.push_back(&curMachInstr);
}
// Push the ADDri instruction
if (curMachInstr.getOpcode() == ARM::ADDri &&
curMachInstr.getOperand(0).isReg()) {
if (curMachInstr.getOperand(0).getReg() == FramePtr) {
epilogInstrs.push_back(&curMachInstr);
}
}
// Push the SUBri instruction
if (curMachInstr.getOpcode() == ARM::SUBri &&
curMachInstr.getOperand(0).getReg() == FramePtr) {
epilogInstrs.push_back(&curMachInstr);
}
if (curMachInstr.getOpcode() == ARM::MOVr) {
if (curMachInstr.getOperand(1).isReg() &&
curMachInstr.getOperand(1).getReg() == ARM::R11 &&
curMachInstr.getOperand(0).isReg() &&
curMachInstr.getOperand(0).getReg() == FramePtr)
epilogInstrs.push_back(&curMachInstr);
}
}
// Eliminate the instructions identified in function epilogue
unsigned int delInstSz = epilogInstrs.size();
for (unsigned int i = 0; i < delInstSz; i++) {
MBB.erase(epilogInstrs[i]);
}
}
return true;
}
/// Analyze stack size base on moving sp.
/// Patterns like:
/// sub sp, sp, #28
void ARMEliminatePrologEpilog::analyzeStackSize(MachineFunction &mf) {
if (mf.size() < 1)
return;
const MachineBasicBlock &mbb = mf.front();
for (const MachineInstr &mi : mbb.instrs()) {
if (mi.getOpcode() == ARM::SUBri && mi.getNumOperands() >= 3 &&
mi.getOperand(0).isReg() && mi.getOperand(0).getReg() == ARM::SP &&
mi.getOperand(1).isReg() && mi.getOperand(1).getReg() == ARM::SP &&
mi.getOperand(2).isImm() && mi.getOperand(2).getImm() > 0) {
mf.getFrameInfo().setStackSize(mi.getOperand(2).getImm());
break;
}
}
}
/// Analyze frame adjustment base on the offset between fp and base sp.
/// Patterns like:
/// add fp, sp, #8
void ARMEliminatePrologEpilog::analyzeFrameAdjustment(MachineFunction &mf) {
if (mf.size() < 1)
return;
const MachineBasicBlock &mbb = mf.front();
for (const MachineInstr &mi : mbb.instrs()) {
if (mi.getOpcode() == ARM::ADDri && mi.getNumOperands() >= 3 &&
mi.getOperand(0).isReg() && mi.getOperand(0).getReg() == ARM::R11 &&
mi.getOperand(1).isReg() && mi.getOperand(1).getReg() == ARM::SP &&
mi.getOperand(2).isImm() && mi.getOperand(2).getImm() > 0) {
mf.getFrameInfo().setOffsetAdjustment(mi.getOperand(2).getImm());
break;
}
}
}
bool ARMEliminatePrologEpilog::eliminate() {
if (PrintPass)
dbgs() << "ARMEliminatePrologEpilog start.\n";
analyzeStackSize(*MF);
analyzeFrameAdjustment(*MF);
bool success = eliminateProlog(*MF);
if (success) {
success = eliminateEpilog(*MF);
}
// For debugging.
if (PrintPass) {
MF->dump();
getCRF()->dump();
}
if (PrintPass)
dbgs() << "ARMEliminatePrologEpilog end.\n";
return !success;
}
bool ARMEliminatePrologEpilog::runOnMachineFunction(MachineFunction &mf) {
bool rtn = false;
init();
rtn = eliminate();
return rtn;
}
#ifdef __cplusplus
extern "C" {
#endif
FunctionPass *InitializeARMEliminatePrologEpilog(ModuleRaiser &mr) {
return new ARMEliminatePrologEpilog(mr);
}
#ifdef __cplusplus
}
#endif

tools/llvm-mctoll/ARM/ARMFunctionPrototype.h

  • This file was added.
//===- ARMFunctionPrototype.h -----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of ARMFunctionPrototype class for
// use by llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMFUNCTIONPROTOTYPE_H
#define LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMFUNCTIONPROTOTYPE_H
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
using namespace llvm;
class ARMFunctionPrototype : public MachineFunctionPass {
public:
static char ID;
ARMFunctionPrototype();
virtual ~ARMFunctionPrototype();
Function *discover(MachineFunction &mf);
bool runOnMachineFunction(MachineFunction &mf);
private:
bool PrintPass;
/// Check the first reference of the reg is USE.
bool isUsedRegiser(unsigned reg, const MachineBasicBlock &mbb);
/// Check the first reference of the reg is DEF.
bool isDefinedRegiser(unsigned reg, const MachineBasicBlock &mbb);
/// Get all arguments types of current MachineFunction.
void genParameterTypes(std::vector<Type *> &paramTypes,
const MachineFunction &mf, LLVMContext &ctx);
/// Get return type of current MachineFunction.
Type *genReturnType(const MachineFunction &mf, LLVMContext &ctx);
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMFUNCTIONPROTOTYPE_H

tools/llvm-mctoll/ARM/ARMFunctionPrototype.cpp

  • This file was added.
//===- ARMFunctionPrototype.h -----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the implementation of ARMFunctionPrototype class
// for use by llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#include "ARMFunctionPrototype.h"
#include "ARMSubtarget.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
using namespace llvm;
char ARMFunctionPrototype::ID = 0;
ARMFunctionPrototype::ARMFunctionPrototype() : MachineFunctionPass(ID) {
PrintPass =
(cl::getRegisteredOptions()["print-after-all"]->getNumOccurrences() > 0);
}
ARMFunctionPrototype::~ARMFunctionPrototype() {}
/// Check the first reference of the reg is USE.
bool ARMFunctionPrototype::isUsedRegiser(unsigned reg,
const MachineBasicBlock &mbb) {
for (MachineBasicBlock::const_iterator ii = mbb.begin(), ie = mbb.end();
ii != ie; ++ii) {
const MachineInstr &mi = *ii;
for (MachineInstr::const_mop_iterator oi = mi.operands_begin(),
oe = mi.operands_end();
oi != oe; oi++) {
const MachineOperand &mo = *oi;
if (mo.isReg() && (mo.getReg() == reg))
return mo.isUse();
}
}
return false;
}
/// Check the first reference of the reg is DEF.
void ARMFunctionPrototype::genParameterTypes(std::vector<Type *> &paramTypes,
const MachineFunction &mf,
LLVMContext &ctx) {
assert(!mf.empty() && "The function body is empty!!!");
const MachineBasicBlock &fmbb = mf.front();
// TODO: Need to track register liveness on CFG.
DenseMap<int, Type *> tarr;
int maxidx = -1; // When the maxidx is -1, means there is no argument.
// The first function argument is from R0.
if (isUsedRegiser(ARM::R0, fmbb)) {
maxidx = 0;
tarr[maxidx] = Type::getInt32Ty(ctx);
}
// The second function argument is from R1.
if (isUsedRegiser(ARM::R1, fmbb)) {
maxidx = 1;
tarr[maxidx] = Type::getInt32Ty(ctx);
}
// The third function argument is from R2.
if (isUsedRegiser(ARM::R2, fmbb)) {
maxidx = 2;
tarr[maxidx] = Type::getInt32Ty(ctx);
}
// The fourth function argument is from R3.
if (isUsedRegiser(ARM::R3, fmbb)) {
maxidx = 3;
tarr[maxidx] = Type::getInt32Ty(ctx);
}
// The rest of function arguments are from stack.
for (MachineFunction::const_iterator mbbi = mf.begin(), mbbe = mf.end();
mbbi != mbbe; ++mbbi) {
const MachineBasicBlock &mbb = *mbbi;
for (MachineBasicBlock::const_iterator mii = mbb.begin(), mie = mbb.end();
mii != mie; ++mii) {
const MachineInstr &mi = *mii;
// Match pattern like ldr r1, [fp, #8].
if (mi.getOpcode() == ARM::LDRi12 && mi.getNumOperands() > 2) {
const MachineOperand &mo = mi.getOperand(1);
const MachineOperand &mc = mi.getOperand(2);
if (mo.isReg() && mo.getReg() == ARM::R11 && mc.isImm()) {
// TODO: Need to check the imm is larger than 0 and it is align
// by 4(32 bit).
int imm = mc.getImm();
if (imm >= 0) {
// The start index of arguments on stack. If the library was
// compiled by clang, it starts from 2. If the library was compiled
// by GNU cross compiler, it starts from 1.
// FIXME: For now, we only treat that the library was complied by
// clang. We will enable the 'if condition' after we are able to
// identify the library was compiled by which compiler.
int idxoff = 2;
if (true /* clang */)
idxoff = 2;
else /* gnu */
idxoff = 1;
int idx = imm / 4 - idxoff + 4; // Plus 4 is to guarantee the first
// stack argument index is after all
// of register arguments' indices.
if (maxidx < idx)
maxidx = idx;
tarr[idx] = Type::getInt32Ty(ctx);
}
}
}
}
}
for (int i = 0; i <= maxidx; ++i) {
if (tarr[i] == nullptr)
paramTypes.push_back(Type::getInt32Ty(ctx));
else
paramTypes.push_back(tarr[i]);
}
}
/// Get all arguments types of current MachineFunction.
bool ARMFunctionPrototype::isDefinedRegiser(unsigned reg,
const MachineBasicBlock &mbb) {
for (MachineBasicBlock::const_reverse_iterator ii = mbb.rbegin(),
ie = mbb.rend();
ii != ie; ++ii) {
const MachineInstr &mi = *ii;
for (MachineInstr::const_mop_iterator oi = mi.operands_begin(),
oe = mi.operands_end();
oi != oe; oi++) {
const MachineOperand &mo = *oi;
if (mo.isReg() && (mo.getReg() == reg)) {
// The return register must not be tied to another register.
// If it was, it should not be return register.
if (mo.isTied())
return false;
return mo.isDef();
}
}
}
return false;
}
/// Get return type of current MachineFunction.
Type *ARMFunctionPrototype::genReturnType(const MachineFunction &mf,
LLVMContext &ctx) {
// TODO: Need to track register liveness on CFG.
Type *retTy;
retTy = Type::getVoidTy(ctx);
for (const MachineBasicBlock &mbb : mf) {
if (mbb.succ_empty()) {
if (isDefinedRegiser(ARM::R0, mbb)) {
// TODO: Need to identify data type, int, long, float or double.
retTy = Type::getInt32Ty(ctx);
break;
}
}
}
return retTy;
}
Function *ARMFunctionPrototype::discover(MachineFunction &mf) {
if (PrintPass)
dbgs() << "ARMFunctionPrototype start.\n";
Function &fn = const_cast<Function &>(mf.getFunction());
LLVMContext &ctx = fn.getContext();
std::vector<Type *> paramTys;
genParameterTypes(paramTys, mf, ctx);
Type *retTy = genReturnType(mf, ctx);
FunctionType *fnTy = FunctionType::get(retTy, paramTys, false);
MachineModuleInfo &mmi = mf.getMMI();
Module *mdl = const_cast<Module *>(mmi.getModule());
mdl->getFunctionList().remove(&fn);
Function *pnfn =
Function::Create(fnTy, GlobalValue::ExternalLinkage, fn.getName(), mdl);
if (PrintPass) {
mf.dump();
pnfn->dump();
}
if (PrintPass)
dbgs() << "ARMFunctionPrototype end.\n";
return pnfn;
}
bool ARMFunctionPrototype::runOnMachineFunction(MachineFunction &mf) {
discover(mf);
return true;
}
#ifdef __cplusplus
extern "C" {
#endif
MachineFunctionPass *InitializeARMFunctionPrototype() {
return new ARMFunctionPrototype();
}
#ifdef __cplusplus
}
#endif

tools/llvm-mctoll/ARM/ARMMachineInstructionRaiser.h

  • This file was added.
//===-- ARMMachineInstructionRaiser.h - Binary raiser utility llvm-mctoll -===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of ARMMachineInstructionRaiser
// class for use by llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMMACHINEINSTRUCTIONRAISER_H
#define LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMMACHINEINSTRUCTIONRAISER_H
#include "MachineInstructionRaiser.h"
class ARMMachineInstructionRaiser : public MachineInstructionRaiser {
public:
ARMMachineInstructionRaiser() = delete;
ARMMachineInstructionRaiser(MachineFunction &machFunc, Module &m,
const ModuleRaiser *mr, MCInstRaiser *mcir);
bool raise();
FunctionType *getRaisedFunctionPrototype();
int getArgumentNumber(unsigned int);
Value *getRegValue(unsigned);
bool buildFuncArgTypeVector(const std::set<MCPhysReg> &,
std::vector<Type *> &);
private:
bool raiseMachineFunction();
// Commonly used LLVM data structures during this phase
MachineRegisterInfo &machRegInfo;
Module &M;
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMMACHINEINSTRUCTIONRAISER_H

tools/llvm-mctoll/ARM/ARMMachineInstructionRaiser.cpp

  • This file was added.
//===-- ARMEliminatePrologEpilog.cpp - Binary raiser utility llvm-mctoll --===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the implementation of ARMMachineInstructionRaiser class
// for use by llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#include "ARMMachineInstructionRaiser.h"
#include "ARMEliminatePrologEpilog.h"
#include "ARMFunctionPrototype.h"
using namespace llvm;
ARMMachineInstructionRaiser::ARMMachineInstructionRaiser(
MachineFunction &machFunc, Module &m, const ModuleRaiser *mr,
MCInstRaiser *mcir)
: MachineInstructionRaiser(machFunc, m, mr, mcir),
machRegInfo(MF.getRegInfo()), M(m) {}
bool ARMMachineInstructionRaiser::raiseMachineFunction() {
ModuleRaiser &rmr = const_cast<ModuleRaiser &>(*MR);
ARMEliminatePrologEpilog epe(rmr);
epe.init(&MF, raisedFunction);
epe.eliminate();
return true;
}
bool ARMMachineInstructionRaiser::raise() {
raiseMachineFunction();
return true;
}
int ARMMachineInstructionRaiser::getArgumentNumber(unsigned int PReg) {
// NYI
assert(false &&
"Unimplemented ARMMachineInstructionRaiser::getArgumentNumber()");
return -1;
}
bool ARMMachineInstructionRaiser::buildFuncArgTypeVector(
const std::set<MCPhysReg> &PhysRegs, std::vector<Type *> &ArgTyVec) {
// NYI
assert(false &&
"Unimplemented ARMMachineInstructionRaiser::buildFuncArgTypeVector()");
return false;
}
Value *ARMMachineInstructionRaiser::getRegValue(unsigned PReg) {
assert(false && "Unimplemented ARMMachineInstructionRaiser::getRegValue()");
return nullptr;
}
FunctionType *ARMMachineInstructionRaiser::getRaisedFunctionPrototype() {
ARMFunctionPrototype AFP;
raisedFunction = AFP.discover(MF);
Function *ori = const_cast<Function *>(&MF.getFunction());
// Insert the map of raised function to tempFunctionPointer.
const_cast<ModuleRaiser *>(MR)->insertPlaceholderRaisedFunctionMap(
raisedFunction, ori);
return raisedFunction->getFunctionType();
}
#ifdef __cplusplus
extern "C" {
#endif
MachineInstructionRaiser *
InitializeARMMachineInstructionRaiser(MachineFunction &machFunc, Module &m,
const ModuleRaiser *mr,
MCInstRaiser *mcir) {
return new ARMMachineInstructionRaiser(machFunc, m, mr, mcir);
}
#ifdef __cplusplus
}
#endif

tools/llvm-mctoll/ARM/ARMRaiserBase.h

  • This file was added.
//===- ARMRaiserBase.h ------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the ARMRaiserBase class. This class
// is a base class of other ARM raisers, it supports some basic utilities for
// sub ARM raisers.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMRAISERBASE_H
#define LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMRAISERBASE_H
#include "ModuleRaiser.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/Pass.h"
using namespace llvm;
class ARMRaiserBase : public FunctionPass {
protected:
ARMRaiserBase() = delete;
ARMRaiserBase(char &PassID, ModuleRaiser &mr) : FunctionPass(PassID), MR(mr) {
PrintPass =
(cl::getRegisteredOptions()["print-after-all"]->getNumOccurrences() >
0);
}
~ARMRaiserBase() override {}
virtual void init(MachineFunction *mf = nullptr, Function *rf = nullptr) {
if (mf)
MF = mf;
if (rf)
RF = rf;
}
virtual bool runOnMachineFunction(MachineFunction &mf) { return false; }
bool runOnFunction(Function &f) override {
RF = &f;
MF = MR.getMachineFunction(&f);
return runOnMachineFunction(*MF);
}
/// Get current raised llvm::Function.
Function *getCRF() { return RF; }
bool PrintPass;
ModuleRaiser &MR;
/// Current raised llvm::Function.
Function *RF;
MachineFunction *MF;
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_ARM_ARMRAISERBASE_H

tools/llvm-mctoll/ARM/CMakeLists.txt

  • This file was added.
include_directories(
${LLVM_MAIN_SRC_DIR}/lib/Target/ARM
${LLVM_BINARY_DIR}/lib/Target/ARM
${CMAKE_CURRENT_SOURCE_DIR}/..
)
if(NOT LLVM_MCTOLL_BUILT_STANDALONE)
set(LLVM_MCTOLL_DEPS intrinsics_gen ARMCommonTableGen)
endif()
add_llvm_library(ARMRaiser
ARMFunctionPrototype.cpp
ARMEliminatePrologEpilog.cpp
ARMMachineInstructionRaiser.cpp
DEPENDS
${LLVM_MCTOLL_DEPS}
)

tools/llvm-mctoll/CMakeLists.txt

  • This file was added.
# Check if llvm-mctoll is built as a standalone project.
if( CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR )
project(BinaryRaiser)
cmake_minimum_required(VERSION 3.4.3)
set(LLVM_MCTOLL_BUILT_STANDALONE TRUE)
find_program(LLVM_CONFIG_PATH "llvm-config" DOC "Path to llvm-config binary")
if(NOT LLVM_CONFIG_PATH)
message(FATAL_ERROR "llvm-config not found: specify LLVM_CONFIG_PATH")
endif()
execute_process(COMMAND "${LLVM_CONFIG_PATH}"
"--assertion-mode"
"--obj-root"
"--bindir"
"--src-root"
"--cmakedir"
"--cxxflags"
RESULT_VARIABLE HAD_ERROR
OUTPUT_VARIABLE LLVM_CONFIG_OUTPUT
OUTPUT_STRIP_TRAILING_WHITESPACE)
if(HAD_ERROR)
message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}")
endif()
string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" LLVM_CONFIG_OUTPUT "${LLVM_CONFIG_OUTPUT}")
list(GET LLVM_CONFIG_OUTPUT 0 ENABLE_ASSERTIONS)
list(GET LLVM_CONFIG_OUTPUT 1 OBJ_ROOT)
list(GET LLVM_CONFIG_OUTPUT 2 TOOLS_BINARY_DIR)
list(GET LLVM_CONFIG_OUTPUT 3 MAIN_SRC_DIR)
list(GET LLVM_CONFIG_OUTPUT 4 LLVM_CMAKE_PATH)
list(GET LLVM_CONFIG_OUTPUT 5 LLVM_CXX_FLAGS)
if(NOT MSVC_IDE)
set(LLVM_ENABLE_ASSERTIONS ${ENABLE_ASSERTIONS}
CACHE BOOL "Enable assertions")
# Assertions should follow llvm-config's.
mark_as_advanced(LLVM_ENABLE_ASSERTIONS)
endif()
set(LLVM_OBJ_ROOT ${OBJ_ROOT} CACHE PATH "Path to LLVM build tree")
set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LLVM_CXX_FLAGS}")
set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin")
set(LLVM_EXTERNAL_LIT ${LLVM_TOOLS_BINARY_DIR}/llvm-lit CACHE PATH "Path to llvm-lit")
file(TO_CMAKE_PATH ${LLVM_OBJ_ROOT} LLVM_BINARY_DIR)
if(NOT EXISTS "${LLVM_CMAKE_PATH}/LLVMConfig.cmake")
message(FATAL_ERROR "LLVMConfig.cmake not found")
endif()
include("${LLVM_CMAKE_PATH}/LLVMConfig.cmake")
list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}")
# They are used as destination of target generators.
set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)
option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)
include (AddLLVM)
include_directories(${LLVM_INCLUDE_DIRS})
include(CheckLibraryExists)
check_library_exists(xar xar_open "" HAVE_LIBXAR)
if(HAVE_LIBXAR)
set(XAR_LIB xar)
endif()
endif()
set(LLVM_MCTOLL_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
set(LLVM_MCTOLL_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
llvm_map_components_to_libnames(llvm_libs
${LLVM_TARGETS_TO_BUILD}
DebugInfoDWARF
DebugInfoPDB
Symbolize
)
set(LLVM_MCTOLL_LIB_DEPS ${llvm_libs})
if(LLVM_TARGETS_TO_BUILD MATCHES "X86")
add_subdirectory(X86)
list(APPEND LLVM_MCTOLL_LIB_DEPS X86Raiser)
endif()
if(LLVM_TARGETS_TO_BUILD MATCHES "ARM")
add_subdirectory(ARM)
list(APPEND LLVM_MCTOLL_LIB_DEPS ARMRaiser)
endif()
add_subdirectory(test)
add_llvm_tool(llvm-mctoll
llvm-mctoll.cpp
COFFDump.cpp
ELFDump.cpp
ExternalFunctions.cpp
MachODump.cpp
WasmDump.cpp
MachineFunctionRaiser.cpp
MCInstOrData.cpp
MCInstRaiser.cpp
EmitRaisedOutputPass.cpp
)
# Link against LLVM libraries and target-specific Raiser libraries
target_link_libraries(llvm-mctoll PRIVATE ${LLVM_MCTOLL_LIB_DEPS})
if(HAVE_LIBXAR)
message(STATUS "Linking xar")
target_link_libraries(llvm-mctoll PRIVATE ${XAR_LIB})
endif()

tools/llvm-mctoll/COFFDump.cpp

  • This file was added.
//===-- COFFDump.cpp - COFF-specific dumper ---------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// \brief This file implements the COFF-specific dumper for llvm-objdump.
/// It outputs the Win64 EH data structures as plain text.
/// The encoding of the unwind codes is described in MSDN:
/// http://msdn.microsoft.com/en-us/library/ck9asaa9.aspx
///
//===----------------------------------------------------------------------===//
#include "llvm-mctoll.h"
#include "llvm/Object/COFF.h"
#include "llvm/Object/COFFImportFile.h"
#include "llvm/Object/ObjectFile.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/Win64EH.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cstring>
#include <system_error>
using namespace llvm;
using namespace object;
using namespace llvm::Win64EH;
// Returns the name of the unwind code.
static StringRef getUnwindCodeTypeName(uint8_t Code) {
switch (Code) {
default:
llvm_unreachable("Invalid unwind code");
case UOP_PushNonVol:
return "UOP_PushNonVol";
case UOP_AllocLarge:
return "UOP_AllocLarge";
case UOP_AllocSmall:
return "UOP_AllocSmall";
case UOP_SetFPReg:
return "UOP_SetFPReg";
case UOP_SaveNonVol:
return "UOP_SaveNonVol";
case UOP_SaveNonVolBig:
return "UOP_SaveNonVolBig";
case UOP_SaveXMM128:
return "UOP_SaveXMM128";
case UOP_SaveXMM128Big:
return "UOP_SaveXMM128Big";
case UOP_PushMachFrame:
return "UOP_PushMachFrame";
}
}
// Returns the name of a referenced register.
static StringRef getUnwindRegisterName(uint8_t Reg) {
switch (Reg) {
default:
llvm_unreachable("Invalid register");
case 0:
return "RAX";
case 1:
return "RCX";
case 2:
return "RDX";
case 3:
return "RBX";
case 4:
return "RSP";
case 5:
return "RBP";
case 6:
return "RSI";
case 7:
return "RDI";
case 8:
return "R8";
case 9:
return "R9";
case 10:
return "R10";
case 11:
return "R11";
case 12:
return "R12";
case 13:
return "R13";
case 14:
return "R14";
case 15:
return "R15";
}
}
// Calculates the number of array slots required for the unwind code.
static unsigned getNumUsedSlots(const UnwindCode &UnwindCode) {
switch (UnwindCode.getUnwindOp()) {
default:
llvm_unreachable("Invalid unwind code");
case UOP_PushNonVol:
case UOP_AllocSmall:
case UOP_SetFPReg:
case UOP_PushMachFrame:
return 1;
case UOP_SaveNonVol:
case UOP_SaveXMM128:
return 2;
case UOP_SaveNonVolBig:
case UOP_SaveXMM128Big:
return 3;
case UOP_AllocLarge:
return (UnwindCode.getOpInfo() == 0) ? 2 : 3;
}
}
// Prints one unwind code. Because an unwind code can occupy up to 3 slots in
// the unwind codes array, this function requires that the correct number of
// slots is provided.
static void printUnwindCode(ArrayRef<UnwindCode> UCs) {
assert(UCs.size() >= getNumUsedSlots(UCs[0]));
outs() << format(" 0x%02x: ", unsigned(UCs[0].u.CodeOffset))
<< getUnwindCodeTypeName(UCs[0].getUnwindOp());
switch (UCs[0].getUnwindOp()) {
case UOP_PushNonVol:
outs() << " " << getUnwindRegisterName(UCs[0].getOpInfo());
break;
case UOP_AllocLarge:
if (UCs[0].getOpInfo() == 0) {
outs() << " " << UCs[1].FrameOffset;
} else {
outs() << " "
<< UCs[1].FrameOffset +
(static_cast<uint32_t>(UCs[2].FrameOffset) << 16);
}
break;
case UOP_AllocSmall:
outs() << " " << ((UCs[0].getOpInfo() + 1) * 8);
break;
case UOP_SetFPReg:
outs() << " ";
break;
case UOP_SaveNonVol:
outs() << " " << getUnwindRegisterName(UCs[0].getOpInfo())
<< format(" [0x%04x]", 8 * UCs[1].FrameOffset);
break;
case UOP_SaveNonVolBig:
outs() << " " << getUnwindRegisterName(UCs[0].getOpInfo())
<< format(" [0x%08x]",
UCs[1].FrameOffset +
(static_cast<uint32_t>(UCs[2].FrameOffset) << 16));
break;
case UOP_SaveXMM128:
outs() << " XMM" << static_cast<uint32_t>(UCs[0].getOpInfo())
<< format(" [0x%04x]", 16 * UCs[1].FrameOffset);
break;
case UOP_SaveXMM128Big:
outs() << " XMM" << UCs[0].getOpInfo()
<< format(" [0x%08x]",
UCs[1].FrameOffset +
(static_cast<uint32_t>(UCs[2].FrameOffset) << 16));
break;
case UOP_PushMachFrame:
outs() << " " << (UCs[0].getOpInfo() ? "w/o" : "w") << " error code";
break;
}
outs() << "\n";
}
static void printAllUnwindCodes(ArrayRef<UnwindCode> UCs) {
for (const UnwindCode *I = UCs.begin(), *E = UCs.end(); I < E;) {
unsigned UsedSlots = getNumUsedSlots(*I);
if (UsedSlots > UCs.size()) {
outs() << "Unwind data corrupted: Encountered unwind op "
<< getUnwindCodeTypeName((*I).getUnwindOp()) << " which requires "
<< UsedSlots << " slots, but only " << UCs.size()
<< " remaining in buffer";
return;
}
printUnwindCode(makeArrayRef(I, E));
I += UsedSlots;
}
}
// Given a symbol sym this functions returns the address and section of it.
static std::error_code
resolveSectionAndAddress(const COFFObjectFile *Obj, const SymbolRef &Sym,
const coff_section *&ResolvedSection,
uint64_t &ResolvedAddr) {
Expected<uint64_t> ResolvedAddrOrErr = Sym.getAddress();
if (!ResolvedAddrOrErr)
return errorToErrorCode(ResolvedAddrOrErr.takeError());
ResolvedAddr = *ResolvedAddrOrErr;
Expected<section_iterator> Iter = Sym.getSection();
if (!Iter)
return errorToErrorCode(Iter.takeError());
ResolvedSection = Obj->getCOFFSection(**Iter);
return std::error_code();
}
// Given a vector of relocations for a section and an offset into this section
// the function returns the symbol used for the relocation at the offset.
static std::error_code resolveSymbol(const std::vector<RelocationRef> &Rels,
uint64_t Offset, SymbolRef &Sym) {
for (auto &R : Rels) {
uint64_t Ofs = R.getOffset();
if (Ofs == Offset) {
Sym = *R.getSymbol();
return std::error_code();
}
}
return object_error::parse_failed;
}
// Given a vector of relocations for a section and an offset into this section
// the function resolves the symbol used for the relocation at the offset and
// returns the section content and the address inside the content pointed to
// by the symbol.
static std::error_code
getSectionContents(const COFFObjectFile *Obj,
const std::vector<RelocationRef> &Rels, uint64_t Offset,
ArrayRef<uint8_t> &Contents, uint64_t &Addr) {
SymbolRef Sym;
if (std::error_code EC = resolveSymbol(Rels, Offset, Sym))
return EC;
const coff_section *Section;
if (std::error_code EC = resolveSectionAndAddress(Obj, Sym, Section, Addr))
return EC;
if (std::error_code EC = Obj->getSectionContents(Section, Contents))
return EC;
return std::error_code();
}
// Given a vector of relocations for a section and an offset into this section
// the function returns the name of the symbol used for the relocation at the
// offset.
static std::error_code resolveSymbolName(const std::vector<RelocationRef> &Rels,
uint64_t Offset, StringRef &Name) {
SymbolRef Sym;
if (std::error_code EC = resolveSymbol(Rels, Offset, Sym))
return EC;
Expected<StringRef> NameOrErr = Sym.getName();
if (!NameOrErr)
return errorToErrorCode(NameOrErr.takeError());
Name = *NameOrErr;
return std::error_code();
}
static void printCOFFSymbolAddress(llvm::raw_ostream &Out,
const std::vector<RelocationRef> &Rels,
uint64_t Offset, uint32_t Disp) {
StringRef Sym;
if (!resolveSymbolName(Rels, Offset, Sym)) {
Out << Sym;
if (Disp > 0)
Out << format(" + 0x%04x", Disp);
} else {
Out << format("0x%04x", Disp);
}
}
static void printSEHTable(const COFFObjectFile *Obj, uint32_t TableVA,
int Count) {
if (Count == 0)
return;
const pe32_header *PE32Header;
error(Obj->getPE32Header(PE32Header));
uint32_t ImageBase = PE32Header->ImageBase;
uintptr_t IntPtr = 0;
error(Obj->getVaPtr(TableVA, IntPtr));
const support::ulittle32_t *P = (const support::ulittle32_t *)IntPtr;
outs() << "SEH Table:";
for (int I = 0; I < Count; ++I)
outs() << format(" 0x%x", P[I] + ImageBase);
outs() << "\n\n";
}
template <typename T>
static void printTLSDirectoryT(const coff_tls_directory<T> *TLSDir) {
size_t FormatWidth = sizeof(T) * 2;
outs() << "TLS directory:"
<< "\n StartAddressOfRawData: "
<< format_hex(TLSDir->StartAddressOfRawData, FormatWidth)
<< "\n EndAddressOfRawData: "
<< format_hex(TLSDir->EndAddressOfRawData, FormatWidth)
<< "\n AddressOfIndex: "
<< format_hex(TLSDir->AddressOfIndex, FormatWidth)
<< "\n AddressOfCallBacks: "
<< format_hex(TLSDir->AddressOfCallBacks, FormatWidth)
<< "\n SizeOfZeroFill: " << TLSDir->SizeOfZeroFill
<< "\n Characteristics: " << TLSDir->Characteristics
<< "\n Alignment: " << TLSDir->getAlignment() << "\n\n";
}
static void printTLSDirectory(const COFFObjectFile *Obj) {
const pe32_header *PE32Header;
error(Obj->getPE32Header(PE32Header));
const pe32plus_header *PE32PlusHeader;
error(Obj->getPE32PlusHeader(PE32PlusHeader));
// Skip if it's not executable.
if (!PE32Header && !PE32PlusHeader)
return;
const data_directory *DataDir;
error(Obj->getDataDirectory(COFF::TLS_TABLE, DataDir));
uintptr_t IntPtr = 0;
if (DataDir->RelativeVirtualAddress == 0)
return;
error(Obj->getRvaPtr(DataDir->RelativeVirtualAddress, IntPtr));
if (PE32Header) {
auto *TLSDir = reinterpret_cast<const coff_tls_directory32 *>(IntPtr);
printTLSDirectoryT(TLSDir);
} else {
auto *TLSDir = reinterpret_cast<const coff_tls_directory64 *>(IntPtr);
printTLSDirectoryT(TLSDir);
}
outs() << "\n";
}
static void printLoadConfiguration(const COFFObjectFile *Obj) {
// Skip if it's not executable.
const pe32_header *PE32Header;
error(Obj->getPE32Header(PE32Header));
if (!PE32Header)
return;
// Currently only x86 is supported
if (Obj->getMachine() != COFF::IMAGE_FILE_MACHINE_I386)
return;
const data_directory *DataDir;
error(Obj->getDataDirectory(COFF::LOAD_CONFIG_TABLE, DataDir));
uintptr_t IntPtr = 0;
if (DataDir->RelativeVirtualAddress == 0)
return;
error(Obj->getRvaPtr(DataDir->RelativeVirtualAddress, IntPtr));
auto *LoadConf = reinterpret_cast<const coff_load_configuration32 *>(IntPtr);
outs() << "Load configuration:"
<< "\n Timestamp: " << LoadConf->TimeDateStamp
<< "\n Major Version: " << LoadConf->MajorVersion
<< "\n Minor Version: " << LoadConf->MinorVersion
<< "\n GlobalFlags Clear: " << LoadConf->GlobalFlagsClear
<< "\n GlobalFlags Set: " << LoadConf->GlobalFlagsSet
<< "\n Critical Section Default Timeout: "
<< LoadConf->CriticalSectionDefaultTimeout
<< "\n Decommit Free Block Threshold: "
<< LoadConf->DeCommitFreeBlockThreshold
<< "\n Decommit Total Free Threshold: "
<< LoadConf->DeCommitTotalFreeThreshold
<< "\n Lock Prefix Table: " << LoadConf->LockPrefixTable
<< "\n Maximum Allocation Size: " << LoadConf->MaximumAllocationSize
<< "\n Virtual Memory Threshold: " << LoadConf->VirtualMemoryThreshold
<< "\n Process Affinity Mask: " << LoadConf->ProcessAffinityMask
<< "\n Process Heap Flags: " << LoadConf->ProcessHeapFlags
<< "\n CSD Version: " << LoadConf->CSDVersion
<< "\n Security Cookie: " << LoadConf->SecurityCookie
<< "\n SEH Table: " << LoadConf->SEHandlerTable
<< "\n SEH Count: " << LoadConf->SEHandlerCount << "\n\n";
printSEHTable(Obj, LoadConf->SEHandlerTable, LoadConf->SEHandlerCount);
outs() << "\n";
}
// Prints import tables. The import table is a table containing the list of
// DLL name and symbol names which will be linked by the loader.
static void printImportTables(const COFFObjectFile *Obj) {
import_directory_iterator I = Obj->import_directory_begin();
import_directory_iterator E = Obj->import_directory_end();
if (I == E)
return;
outs() << "The Import Tables:\n";
for (const ImportDirectoryEntryRef &DirRef : Obj->import_directories()) {
const coff_import_directory_table_entry *Dir;
StringRef Name;
if (DirRef.getImportTableEntry(Dir))
return;
if (DirRef.getName(Name))
return;
outs() << format(" lookup %08x time %08x fwd %08x name %08x addr %08x\n\n",
static_cast<uint32_t>(Dir->ImportLookupTableRVA),
static_cast<uint32_t>(Dir->TimeDateStamp),
static_cast<uint32_t>(Dir->ForwarderChain),
static_cast<uint32_t>(Dir->NameRVA),
static_cast<uint32_t>(Dir->ImportAddressTableRVA));
outs() << " DLL Name: " << Name << "\n";
outs() << " Hint/Ord Name\n";
for (const ImportedSymbolRef &Entry : DirRef.imported_symbols()) {
bool IsOrdinal;
if (Entry.isOrdinal(IsOrdinal))
return;
if (IsOrdinal) {
uint16_t Ordinal;
if (Entry.getOrdinal(Ordinal))
return;
outs() << format(" % 6d\n", Ordinal);
continue;
}
uint32_t HintNameRVA;
if (Entry.getHintNameRVA(HintNameRVA))
return;
uint16_t Hint;
StringRef Name;
if (Obj->getHintName(HintNameRVA, Hint, Name))
return;
outs() << format(" % 6d ", Hint) << Name << "\n";
}
outs() << "\n";
}
}
// Prints export tables. The export table is a table containing the list of
// exported symbol from the DLL.
static void printExportTable(const COFFObjectFile *Obj) {
outs() << "Export Table:\n";
export_directory_iterator I = Obj->export_directory_begin();
export_directory_iterator E = Obj->export_directory_end();
if (I == E)
return;
StringRef DllName;
uint32_t OrdinalBase;
if (I->getDllName(DllName))
return;
if (I->getOrdinalBase(OrdinalBase))
return;
outs() << " DLL name: " << DllName << "\n";
outs() << " Ordinal base: " << OrdinalBase << "\n";
outs() << " Ordinal RVA Name\n";
for (; I != E; I = ++I) {
uint32_t Ordinal;
if (I->getOrdinal(Ordinal))
return;
uint32_t RVA;
if (I->getExportRVA(RVA))
return;
bool IsForwarder;
if (I->isForwarder(IsForwarder))
return;
if (IsForwarder) {
// Export table entries can be used to re-export symbols that
// this COFF file is imported from some DLLs. This is rare.
// In most cases IsForwarder is false.
outs() << format(" % 4d ", Ordinal);
} else {
outs() << format(" % 4d %# 8x", Ordinal, RVA);
}
StringRef Name;
if (I->getSymbolName(Name))
continue;
if (!Name.empty())
outs() << " " << Name;
if (IsForwarder) {
StringRef S;
if (I->getForwardTo(S))
return;
outs() << " (forwarded to " << S << ")";
}
outs() << "\n";
}
}
// Given the COFF object file, this function returns the relocations for .pdata
// and the pointer to "runtime function" structs.
static bool getPDataSection(const COFFObjectFile *Obj,
std::vector<RelocationRef> &Rels,
const RuntimeFunction *&RFStart, int &NumRFs) {
for (const SectionRef &Section : Obj->sections()) {
StringRef Name;
error(Section.getName(Name));
if (Name != ".pdata")
continue;
const coff_section *Pdata = Obj->getCOFFSection(Section);
for (const RelocationRef &Reloc : Section.relocations())
Rels.push_back(Reloc);
// Sort relocations by address.
std::sort(Rels.begin(), Rels.end(), RelocAddressLess);
ArrayRef<uint8_t> Contents;
error(Obj->getSectionContents(Pdata, Contents));
if (Contents.empty())
continue;
RFStart = reinterpret_cast<const RuntimeFunction *>(Contents.data());
NumRFs = Contents.size() / sizeof(RuntimeFunction);
return true;
}
return false;
}
static void printWin64EHUnwindInfo(const Win64EH::UnwindInfo *UI) {
// The casts to int are required in order to output the value as number.
// Without the casts the value would be interpreted as char data (which
// results in garbage output).
outs() << " Version: " << static_cast<int>(UI->getVersion()) << "\n";
outs() << " Flags: " << static_cast<int>(UI->getFlags());
if (UI->getFlags()) {
if (UI->getFlags() & UNW_ExceptionHandler)
outs() << " UNW_ExceptionHandler";
if (UI->getFlags() & UNW_TerminateHandler)
outs() << " UNW_TerminateHandler";
if (UI->getFlags() & UNW_ChainInfo)
outs() << " UNW_ChainInfo";
}
outs() << "\n";
outs() << " Size of prolog: " << static_cast<int>(UI->PrologSize) << "\n";
outs() << " Number of Codes: " << static_cast<int>(UI->NumCodes) << "\n";
// Maybe this should move to output of UOP_SetFPReg?
if (UI->getFrameRegister()) {
outs() << " Frame register: "
<< getUnwindRegisterName(UI->getFrameRegister()) << "\n";
outs() << " Frame offset: " << 16 * UI->getFrameOffset() << "\n";
} else {
outs() << " No frame pointer used\n";
}
if (UI->getFlags() & (UNW_ExceptionHandler | UNW_TerminateHandler)) {
// FIXME: Output exception handler data
} else if (UI->getFlags() & UNW_ChainInfo) {
// FIXME: Output chained unwind info
}
if (UI->NumCodes)
outs() << " Unwind Codes:\n";
printAllUnwindCodes(makeArrayRef(&UI->UnwindCodes[0], UI->NumCodes));
outs() << "\n";
outs().flush();
}
/// Prints out the given RuntimeFunction struct for x64, assuming that Obj is
/// pointing to an executable file.
static void printRuntimeFunction(const COFFObjectFile *Obj,
const RuntimeFunction &RF) {
if (!RF.StartAddress)
return;
outs() << "Function Table:\n"
<< format(" Start Address: 0x%04x\n",
static_cast<uint32_t>(RF.StartAddress))
<< format(" End Address: 0x%04x\n",
static_cast<uint32_t>(RF.EndAddress))
<< format(" Unwind Info Address: 0x%04x\n",
static_cast<uint32_t>(RF.UnwindInfoOffset));
uintptr_t addr;
if (Obj->getRvaPtr(RF.UnwindInfoOffset, addr))
return;
printWin64EHUnwindInfo(reinterpret_cast<const Win64EH::UnwindInfo *>(addr));
}
/// Prints out the given RuntimeFunction struct for x64, assuming that Obj is
/// pointing to an object file. Unlike executable, fields in RuntimeFunction
/// struct are filled with zeros, but instead there are relocations pointing to
/// them so that the linker will fill targets' RVAs to the fields at link
/// time. This function interprets the relocations to find the data to be used
/// in the resulting executable.
static void printRuntimeFunctionRels(const COFFObjectFile *Obj,
const RuntimeFunction &RF,
uint64_t SectionOffset,
const std::vector<RelocationRef> &Rels) {
outs() << "Function Table:\n";
outs() << " Start Address: ";
printCOFFSymbolAddress(outs(), Rels,
SectionOffset +
/*offsetof(RuntimeFunction, StartAddress)*/ 0,
RF.StartAddress);
outs() << "\n";
outs() << " End Address: ";
printCOFFSymbolAddress(outs(), Rels,
SectionOffset +
/*offsetof(RuntimeFunction, EndAddress)*/ 4,
RF.EndAddress);
outs() << "\n";
outs() << " Unwind Info Address: ";
printCOFFSymbolAddress(outs(), Rels,
SectionOffset +
/*offsetof(RuntimeFunction, UnwindInfoOffset)*/ 8,
RF.UnwindInfoOffset);
outs() << "\n";
ArrayRef<uint8_t> XContents;
uint64_t UnwindInfoOffset = 0;
error(
getSectionContents(Obj, Rels,
SectionOffset +
/*offsetof(RuntimeFunction, UnwindInfoOffset)*/ 8,
XContents, UnwindInfoOffset));
if (XContents.empty())
return;
UnwindInfoOffset += RF.UnwindInfoOffset;
if (UnwindInfoOffset > XContents.size())
return;
auto *UI = reinterpret_cast<const Win64EH::UnwindInfo *>(XContents.data() +
UnwindInfoOffset);
printWin64EHUnwindInfo(UI);
}
void llvm::printCOFFUnwindInfo(const COFFObjectFile *Obj) {
if (Obj->getMachine() != COFF::IMAGE_FILE_MACHINE_AMD64) {
errs() << "Unsupported image machine type "
"(currently only AMD64 is supported).\n";
return;
}
std::vector<RelocationRef> Rels;
const RuntimeFunction *RFStart;
int NumRFs;
if (!getPDataSection(Obj, Rels, RFStart, NumRFs))
return;
ArrayRef<RuntimeFunction> RFs(RFStart, NumRFs);
bool IsExecutable = Rels.empty();
if (IsExecutable) {
for (const RuntimeFunction &RF : RFs)
printRuntimeFunction(Obj, RF);
return;
}
for (const RuntimeFunction &RF : RFs) {
uint64_t SectionOffset =
std::distance(RFs.begin(), &RF) * sizeof(RuntimeFunction);
printRuntimeFunctionRels(Obj, RF, SectionOffset, Rels);
}
}
void llvm::printCOFFFileHeader(const object::ObjectFile *Obj) {
const COFFObjectFile *file = dyn_cast<const COFFObjectFile>(Obj);
printTLSDirectory(file);
printLoadConfiguration(file);
printImportTables(file);
printExportTable(file);
}
void llvm::printCOFFSymbolTable(const object::COFFImportFile *i) {
unsigned Index = 0;
bool IsCode = i->getCOFFImportHeader()->getType() == COFF::IMPORT_CODE;
for (const object::BasicSymbolRef &Sym : i->symbols()) {
std::string Name;
raw_string_ostream NS(Name);
Sym.printName(NS);
NS.flush();
outs() << "[" << format("%2d", Index) << "]"
<< "(sec " << format("%2d", 0) << ")"
<< "(fl 0x00)" // Flag bits, which COFF doesn't have.
<< "(ty " << format("%3x", (IsCode && Index) ? 32 : 0) << ")"
<< "(scl " << format("%3x", 0) << ") "
<< "(nx " << 0 << ") "
<< "0x" << format("%08x", 0) << " " << Name << '\n';
++Index;
}
}
void llvm::printCOFFSymbolTable(const COFFObjectFile *coff) {
for (unsigned SI = 0, SE = coff->getNumberOfSymbols(); SI != SE; ++SI) {
Expected<COFFSymbolRef> Symbol = coff->getSymbol(SI);
StringRef Name;
error(errorToErrorCode(Symbol.takeError()));
error(coff->getSymbolName(*Symbol, Name));
outs() << "[" << format("%2d", SI) << "]"
<< "(sec " << format("%2d", int(Symbol->getSectionNumber())) << ")"
<< "(fl 0x00)" // Flag bits, which COFF doesn't have.
<< "(ty " << format("%3x", unsigned(Symbol->getType())) << ")"
<< "(scl " << format("%3x", unsigned(Symbol->getStorageClass()))
<< ") "
<< "(nx " << unsigned(Symbol->getNumberOfAuxSymbols()) << ") "
<< "0x" << format("%08x", unsigned(Symbol->getValue())) << " "
<< Name << "\n";
for (unsigned AI = 0, AE = Symbol->getNumberOfAuxSymbols(); AI < AE;
++AI, ++SI) {
if (Symbol->isSectionDefinition()) {
const coff_aux_section_definition *asd;
error(coff->getAuxSymbol<coff_aux_section_definition>(SI + 1, asd));
int32_t AuxNumber = asd->getNumber(Symbol->isBigObj());
outs() << "AUX "
<< format("scnlen 0x%x nreloc %d nlnno %d checksum 0x%x ",
unsigned(asd->Length),
unsigned(asd->NumberOfRelocations),
unsigned(asd->NumberOfLinenumbers),
unsigned(asd->CheckSum))
<< format("assoc %d comdat %d\n", unsigned(AuxNumber),
unsigned(asd->Selection));
} else if (Symbol->isFileRecord()) {
const char *FileName;
error(coff->getAuxSymbol<char>(SI + 1, FileName));
StringRef Name(FileName, Symbol->getNumberOfAuxSymbols() *
coff->getSymbolTableEntrySize());
outs() << "AUX " << Name.rtrim(StringRef("\0", 1)) << '\n';
SI = SI + Symbol->getNumberOfAuxSymbols();
break;
} else if (Symbol->isWeakExternal()) {
const coff_aux_weak_external *awe;
error(coff->getAuxSymbol<coff_aux_weak_external>(SI + 1, awe));
outs() << "AUX "
<< format("indx %d srch %d\n",
static_cast<uint32_t>(awe->TagIndex),
static_cast<uint32_t>(awe->Characteristics));
} else {
outs() << "AUX Unknown\n";
}
}
}
}

tools/llvm-mctoll/ELFDump.cpp

  • This file was added.
//===-- ELFDump.cpp - ELF-specific dumper -----------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// \brief This file implements the ELF-specific dumper for llvm-objdump.
///
//===----------------------------------------------------------------------===//
#include "llvm-mctoll.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
using namespace llvm::object;
template <class ELFT> void printProgramHeaders(const ELFFile<ELFT> *o) {
typedef ELFFile<ELFT> ELFO;
outs() << "Program Header:\n";
auto ProgramHeaderOrError = o->program_headers();
if (!ProgramHeaderOrError)
report_fatal_error(
errorToErrorCode(ProgramHeaderOrError.takeError()).message());
for (const typename ELFO::Elf_Phdr &Phdr : *ProgramHeaderOrError) {
switch (Phdr.p_type) {
case ELF::PT_DYNAMIC:
outs() << " DYNAMIC ";
break;
case ELF::PT_GNU_EH_FRAME:
outs() << "EH_FRAME ";
break;
case ELF::PT_GNU_RELRO:
outs() << " RELRO ";
break;
case ELF::PT_GNU_STACK:
outs() << " STACK ";
break;
case ELF::PT_INTERP:
outs() << " INTERP ";
break;
case ELF::PT_LOAD:
outs() << " LOAD ";
break;
case ELF::PT_NOTE:
outs() << " NOTE ";
break;
case ELF::PT_OPENBSD_BOOTDATA:
outs() << " OPENBSD_BOOTDATA ";
break;
case ELF::PT_OPENBSD_RANDOMIZE:
outs() << " OPENBSD_RANDOMIZE ";
break;
case ELF::PT_OPENBSD_WXNEEDED:
outs() << " OPENBSD_WXNEEDED ";
break;
case ELF::PT_PHDR:
outs() << " PHDR ";
break;
case ELF::PT_TLS:
outs() << " TLS ";
break;
default:
outs() << " UNKNOWN ";
}
const char *Fmt = ELFT::Is64Bits ? "0x%016" PRIx64 " " : "0x%08" PRIx64 " ";
outs() << "off " << format(Fmt, (uint64_t)Phdr.p_offset) << "vaddr "
<< format(Fmt, (uint64_t)Phdr.p_vaddr) << "paddr "
<< format(Fmt, (uint64_t)Phdr.p_paddr)
<< format("align 2**%u\n",
countTrailingZeros<uint64_t>(Phdr.p_align))
<< " filesz " << format(Fmt, (uint64_t)Phdr.p_filesz)
<< "memsz " << format(Fmt, (uint64_t)Phdr.p_memsz) << "flags "
<< ((Phdr.p_flags & ELF::PF_R) ? "r" : "-")
<< ((Phdr.p_flags & ELF::PF_W) ? "w" : "-")
<< ((Phdr.p_flags & ELF::PF_X) ? "x" : "-") << "\n";
}
outs() << "\n";
}
void llvm::printELFFileHeader(const object::ObjectFile *Obj) {
// Little-endian 32-bit
if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
printProgramHeaders(ELFObj->getELFFile());
// Big-endian 32-bit
if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
printProgramHeaders(ELFObj->getELFFile());
// Little-endian 64-bit
if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
printProgramHeaders(ELFObj->getELFFile());
// Big-endian 64-bit
if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
printProgramHeaders(ELFObj->getELFFile());
}

tools/llvm-mctoll/EmitRaisedOutputPass.h

  • This file was added.
//===----------- EmitRaisedOutputPass.h -------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of EmitRaisedOutputPass for use by
// llvm-mctoll. This class is provided to inhibit printing of target line
// and keep the resulting output architecture-neutral.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_EMITRAISEDOUTPUTPASS_H
#define LLVM_TOOLS_LLVM_MCTOLL_EMITRAISEDOUTPUTPASS_H
#include "llvm/Bitcode/BitcodeWriterPass.h"
#include "llvm/IR/IRPrintingPasses.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h"
#include "llvm/Target/TargetMachine.h"
using namespace llvm;
class EmitRaisedOutputPass : public ModulePass {
TargetMachine::CodeGenFileType OutFileType;
PrintModulePass PrintAsmPass;
BitcodeWriterPass PrintBitCodePass;
public:
static char ID;
EmitRaisedOutputPass()
: ModulePass(ID), OutFileType(TargetMachine::CGFT_Null),
PrintBitCodePass(dbgs()) {}
EmitRaisedOutputPass(raw_ostream &OS, TargetMachine::CodeGenFileType CGFT,
const std::string &Banner = "",
bool ShouldPreserveUseListOrder = false)
: ModulePass(ID), OutFileType(CGFT),
PrintAsmPass(OS, Banner, ShouldPreserveUseListOrder),
PrintBitCodePass(OS, ShouldPreserveUseListOrder) {}
bool runOnModule(Module &M) override;
void getAnalysisUsage(AnalysisUsage &AU) const override;
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_EMITRAISEDOUTPUTPASS_H

tools/llvm-mctoll/EmitRaisedOutputPass.cpp

  • This file was added.
//===- EmitRaisedOutputPass.cpp - Binary raiser utility llvm-mctoll -----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the implementation of EmitRaisedOutputPass
// for use by llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#include "EmitRaisedOutputPass.h"
char EmitRaisedOutputPass::ID = 0;
bool EmitRaisedOutputPass::runOnModule(Module &M) {
ModuleAnalysisManager DummyMAM;
// Save current data layout of the module
auto DL = M.getDataLayout();
// Set data layout to prevent emiting of architecture-specific information in
// the output.
M.setDataLayout("");
// Call the appropriate printer
switch (OutFileType) {
case TargetMachine::CGFT_AssemblyFile:
PrintAsmPass.run(M, DummyMAM);
break;
case TargetMachine::CGFT_ObjectFile:
PrintBitCodePass.run(M, DummyMAM);
break;
case TargetMachine::CGFT_Null:
// Do nothing - corresponds to the command line option
// -output-format=null
break;
}
// restore data layout information to the module.
M.setDataLayout(DL);
return false;
}
void EmitRaisedOutputPass::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
}

tools/llvm-mctoll/ExternalFunctions.h

  • This file was added.
//===-- ExternalFunctions.h - Binary raiser utility llvm-mctoll -------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the ExternalFunction class
// and the table of known external functions.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_EXTERNALFUNCTIONS_H
#define LLVM_TOOLS_LLVM_MCTOLL_EXTERNALFUNCTIONS_H
#include "llvm/IR/Function.h"
#include "llvm/IR/Module.h"
using namespace llvm;
class ExternalFunctions {
ExternalFunctions(){};
~ExternalFunctions(){};
typedef struct {
StringRef ReturnType;
std::vector<StringRef> Arguments;
bool isVariadic;
} RetAndArgs;
public:
static Function *Create(StringRef &, Module &);
static Type *getPrimitiveType(const StringRef &, LLVMContext &);
// Table of known glibc function prototypes
static const std::map<StringRef, ExternalFunctions::RetAndArgs>
GlibcFunctions;
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_EXTERNALFUNCTIONS_H

tools/llvm-mctoll/ExternalFunctions.cpp

  • This file was added.
//===-- ExternalFunctions.h - Binary raiser utility llvm-mctoll -------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the implementation of the ExternalFunction class
// and the table of known external functions.
//
//===----------------------------------------------------------------------===//
#include "ExternalFunctions.h"
const std::map<StringRef, ExternalFunctions::RetAndArgs>
ExternalFunctions::GlibcFunctions = {
{"printf", {"i32", {"i8*"}, true}},
{"malloc", {"i8*", {"i64"}, false}},
{"memcpy", {"i8*", {"i8*", "i8*", "i64"}, false}},
{"strcpy", {"i8*", {"i8*", "i8*"}, false}},
{"__isoc99_scanf", {"i32", {"i8*"}, true}},
{"time", {"i64", {"i64*"}, false}}};
// Given the primitive type's string representation, return the Type*
// corresponding to it.
Type *ExternalFunctions::getPrimitiveType(const StringRef &TypeStr,
LLVMContext &llvmCtx) {
Type *retType = nullptr;
if (TypeStr.equals("void")) {
retType = Type::getVoidTy(llvmCtx);
} else if (TypeStr.equals("i8")) {
retType = Type::getInt8Ty(llvmCtx);
} else if (TypeStr.equals("i16")) {
retType = Type::getInt16Ty(llvmCtx);
} else if (TypeStr.equals("i32")) {
retType = Type::getInt32Ty(llvmCtx);
} else if (TypeStr.equals("i64")) {
retType = Type::getInt64Ty(llvmCtx);
} else if (TypeStr.equals("i8*")) {
retType = Type::getInt8PtrTy(llvmCtx);
} else if (TypeStr.equals("i16*")) {
retType = Type::getInt16PtrTy(llvmCtx);
} else if (TypeStr.equals("i32*")) {
retType = Type::getInt32PtrTy(llvmCtx);
} else if (TypeStr.equals("i64*")) {
retType = Type::getInt64PtrTy(llvmCtx);
}
assert((retType != nullptr) &&
"Unsupported primitive type specified in known function prototype");
return retType;
}
// Construct and return a Function* corresponding to a known glibc function.
Function *ExternalFunctions::Create(StringRef &CFuncName, Module &module) {
Function *Func = nullptr;
llvm::LLVMContext &llvmContext(module.getContext());
FunctionType *FuncType = nullptr;
auto iter = ExternalFunctions::GlibcFunctions.find(CFuncName);
if (iter == ExternalFunctions::GlibcFunctions.end()) {
errs() << CFuncName.data() << "\n";
assert(false && "Unspported undefined function");
}
Func = module.getFunction(CFuncName);
if (Func == nullptr) {
const ExternalFunctions::RetAndArgs &retAndArgs = iter->second;
Type *RetType =
ExternalFunctions::getPrimitiveType(retAndArgs.ReturnType, llvmContext);
std::vector<Type *> ArgVec;
for (StringRef arg : retAndArgs.Arguments) {
Type *argType = ExternalFunctions::getPrimitiveType(arg, llvmContext);
ArgVec.push_back(argType);
}
ArrayRef<Type *> Args(ArgVec);
FuncType = FunctionType::get(RetType, Args, retAndArgs.isVariadic);
if (FuncType == nullptr) {
errs() << CFuncName.data() << "\n";
assert(false &&
"Failed to construct function type for external function");
}
Constant *FC = module.getOrInsertFunction(CFuncName, FuncType);
assert(isa<Function>(FC) && "Expect Function");
Func = reinterpret_cast<Function *>(FC);
}
return Func;
}

tools/llvm-mctoll/LICENSE.TXT

  • This file was added.
==============================================================================
LLVM Release License
==============================================================================
University of Illinois/NCSA
Open Source License
Copyright (c) 2003-2017 University of Illinois at Urbana-Champaign.
All rights reserved.
Developed by:
LLVM Team
University of Illinois at Urbana-Champaign
http://llvm.org
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal with
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimers.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimers in the
documentation and/or other materials provided with the distribution.
* Neither the names of the LLVM Team, University of Illinois at
Urbana-Champaign, nor the names of its contributors may be used to
endorse or promote products derived from this Software without specific
prior written permission.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
SOFTWARE.
==============================================================================
Copyrights and Licenses for Third Party Software Distributed with LLVM:
==============================================================================
The LLVM software contains code written by third parties. Such software will
have its own individual LICENSE.TXT file in the directory in which it appears.
This file will describe the copyrights, license, and restrictions which apply
to that code.
The disclaimer of warranty in the University of Illinois Open Source License
applies to all code in the LLVM Distribution, and nothing in any of the
other licenses gives permission to use the names of the LLVM Team or the
University of Illinois to endorse or promote products derived from this
Software.
The following pieces of software have additional or alternate copyrights,
licenses, and/or restrictions:
Program Directory
------- ---------
Google Test llvm/utils/unittest/googletest
OpenBSD regex llvm/lib/Support/{reg*, COPYRIGHT.regex}
pyyaml tests llvm/test/YAMLParser/{*.data, LICENSE.TXT}
ARM contributions llvm/lib/Target/ARM/LICENSE.TXT
md5 contributions llvm/lib/Support/MD5.cpp llvm/include/llvm/Support/MD5.h

tools/llvm-mctoll/LLVMBuild.txt

  • This file was added.
;===- ./tools/llvm-mctoll/LLVMBuild.txt -----------------------*- Conf -*--===;
;
; The LLVM Compiler Infrastructure
;
; This file is distributed under the University of Illinois Open Source
; License. See LICENSE.TXT for details.
;
;===------------------------------------------------------------------------===;
;
; This is an LLVMBuild description file for the components in this subdirectory.
;
; For more information on the LLVMBuild system, please see:
;
; http://llvm.org/docs/LLVMBuild.html
;
;===------------------------------------------------------------------------===;
[component_0]
type = Tool
name = llvm-mctoll
parent = Tools
required_libraries = DebugInfoDWARF DebugInfoPDB Symbolize

tools/llvm-mctoll/LLVMVersion.txt

  • This file was added.
NOTE: This information is expected to be updated each time an updated
LLVM/Clang tree is used to build llvm-mctoll.
Following is the tip of the git trees used for successful build of llvm-mctoll.
llvm:
commit f8fba9029f6973515711af39198fab1c940d927e
Author: Anastasis Grammenos <anastasis.gramm2@gmail.com>
Date: Fri Aug 3 20:27:13 2018 +0000
[TRE][DebugInfo] Preserve Debug Location in new branch instruction
There are two branch instructions created
so the new test covers them both.
Differential Revision: https://reviews.llvm.org/D50263
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@338917 91177308-0d34-0410-b5e6-96231b3b80d8
tools/clang:
commit 18481d833dc0b2f992b8b99e2a9d5347721bfd68
Author: Reka Kovacs <rekanikolett@gmail.com>
Date: Fri Aug 3 20:42:02 2018 +0000
[analyzer] Add test for a crash fixed in r338775.
Do not crash if a CXXRecordDecl cannot be obtained for an object.
Special thanks for the reproduction to Alexander Kornienko.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@338918 91177308-0d34-0410-b5e6-96231b3b80d8

tools/llvm-mctoll/MCInstOrData.h

  • This file was added.
//===---- MCInstOrData.h - Binary raiser utility llvm-mctoll --------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of MCInstOrData class for use by
// llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_MCINSTORDATA_H
#define LLVM_TOOLS_LLVM_MCTOLL_MCINSTORDATA_H
#include "llvm/MC/MCInst.h"
using namespace llvm;
class MCInstOrData {
private:
enum class Tag { DATA, INSTRUCTION };
union {
uint32_t d;
MCInst i;
};
Tag type;
public:
~MCInstOrData();
MCInstOrData &operator=(const MCInstOrData &);
MCInstOrData(const MCInstOrData &);
MCInstOrData(const MCInst &);
MCInstOrData(const uint32_t);
MCInst get_mcInst() const;
uint32_t get_data() const;
bool is_data() const { return (type == Tag::DATA); }
bool is_mcInst() const { return (type == Tag::INSTRUCTION); }
void dump() const;
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_MCINSTRAISER_H

tools/llvm-mctoll/MCInstOrData.cpp

  • This file was added.
//===-- MCInstOrData.cpp - Binary raiser utility llvm-mctoll --------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the implementation of MCInstrOrData class for use by
// llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#include "MCInstOrData.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
MCInstOrData::MCInstOrData(const MCInstOrData &v) {
type = v.type;
switch (v.type) {
case Tag::DATA:
d = v.d;
break;
case Tag::INSTRUCTION:
new (&i) MCInst(v.i);
}
}
MCInstOrData::MCInstOrData(const MCInst &v) {
type = Tag::INSTRUCTION;
new (&i) MCInst(v); // placement new: explicitly construct MCInst
}
MCInstOrData::MCInstOrData(const uint32_t v) {
type = Tag::DATA;
d = v;
}
uint32_t MCInstOrData::get_data() const {
assert(type == Tag::DATA);
return d;
}
MCInst MCInstOrData::get_mcInst() const {
assert(type == Tag::INSTRUCTION);
return i;
}
// This is needed because of user-defined variant MCInst being part of MCInst
MCInstOrData &MCInstOrData::operator=(const MCInstOrData &e) {
if (type == Tag::INSTRUCTION && e.type == Tag::INSTRUCTION) {
i = e.i; // Usual MCInst assignment
return *this;
}
if (type == Tag::INSTRUCTION)
i.~MCInst(); // Explicit destroy
switch (e.type) {
case Tag::DATA:
d = e.d;
break;
case Tag::INSTRUCTION:
new (&i) MCInst(e.i);
type = e.type;
}
return *this;
}
void MCInstOrData::dump() const {
switch (type) {
case Tag::DATA:
outs() << "0x" << format("%04" PRIx16, d) << "\n";
break;
case Tag::INSTRUCTION:
i.dump();
break;
}
}
MCInstOrData::~MCInstOrData() {
if (type == Tag::INSTRUCTION)
i.~MCInst(); // explicit destroy
}

tools/llvm-mctoll/MCInstRaiser.h

  • This file was added.
//===---- MCInstRaiser.h - Binary raiser utility llvm-mctoll --------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of MCInstRaiser class for use by
// llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_MCINSTRAISER_H
#define LLVM_TOOLS_LLVM_MCTOLL_MCINSTRAISER_H
#include "MCInstOrData.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/MC/MCInstrAnalysis.h"
#include <map>
#include <set>
#include <utility>
#include <vector>
using namespace llvm;
// Class that encapsulates raising for MCInst vector to MachineInstrs
class MCInstRaiser {
public:
using const_mcinst_iter = std::map<uint64_t, MCInstOrData>::const_iterator;
MCInstRaiser(uint64_t fStart, uint64_t fEnd)
: FuncStart(fStart), FuncEnd(fEnd), dataInCode(false){};
void addTarget(uint64_t targetIndex) {
// Add targetIndex only if it falls within the function start and end
// assert((targetIndex >= FuncStart) && (targetIndex <= FuncEnd) &&
// "Failed to add target that is outside the function range");
if (!((targetIndex >= FuncStart) && (targetIndex <= FuncEnd))) {
errs() << "*** WARNING Out of range target not added.\n";
return;
}
targetIndices.insert(targetIndex);
}
void addMCInstOrData(uint64_t index, MCInstOrData mcInst);
void buildCFG(MachineFunction &MF, const MCInstrAnalysis *mia,
const MCInstrInfo *mii);
std::set<uint64_t> getTargetIndices() const { return targetIndices; }
uint64_t getFuncStart() const { return FuncStart; }
uint64_t getFuncEnd() const { return FuncEnd; }
// Change the value of function end to a new value greater than current value
bool adjustFuncEnd(uint64_t n);
// Is Index in range of this function?
bool isMCInstInRange(uint64_t Index) {
return ((Index >= FuncStart) && (Index <= FuncEnd));
}
// Dump routine
void dump() const;
// Data in Code
void setDataInCode(bool v) { dataInCode = v; }
bool hasDataInCode() { return dataInCode; }
// Get the MBB number that corresponds to MCInst at Offset.
// MBB has the raised MachineInstr corresponding to MCInst at
// Offset is the first instruction
uint64_t getMBBNumberOfMCInstOffset(uint64_t Offset) const {
auto iter = mcInstToMBBNum.find(Offset);
assert(iter != mcInstToMBBNum.end() && "Non-existent MCInst offset");
return (*iter).second;
}
// Returns the iterator pointing to MCInstOrData at Offset in
// input instruction stream.
const_mcinst_iter getMCInstAt(uint64_t Offset) const {
return mcInstMap.find(Offset);
}
const_mcinst_iter const_mcinstr_end() const { return mcInstMap.end(); }
// Get the size of instruction
uint64_t getMCInstSize(uint64_t Offset) const {
const_mcinst_iter iter = mcInstMap.find(Offset);
const_mcinst_iter end = mcInstMap.end();
uint64_t InstSize = 0;
assert(iter != end && "Attempt to find MCInst at non-existent offset");
if (iter.operator++() != end) {
uint64_t NextOffset = (*iter).first;
InstSize = NextOffset - Offset;
} else {
// The instruction at Offset is the last instriuction in the input stream
assert(Offset < FuncEnd &&
"Attempt to find MCInst at offset beyond function end");
InstSize = FuncEnd - Offset;
}
return InstSize;
}
uint64_t getMCInstIndex(const MachineInstr &MI) {
unsigned NumExpOps = MI.getNumExplicitOperands();
const MachineOperand &MO = MI.getOperand(NumExpOps);
assert(MO.isMetadata() &&
"Unexpected non-metadata operand in branch instruction");
const MDNode *MDN = MO.getMetadata();
// Unwrap metadata of the instruction to get the MCInstIndex of
// the MCInst corresponding to this MachineInstr.
ConstantAsMetadata *CAM = dyn_cast<ConstantAsMetadata>(MDN->getOperand(0));
assert(CAM != nullptr && "Unexpected metadata type");
Constant *CV = CAM->getValue();
ConstantInt *CI = dyn_cast<ConstantInt>(CV);
assert(CI != nullptr && "Unexpected metadata constant type");
APInt ArbPrecInt = CI->getValue();
return ArbPrecInt.getSExtValue();
}
private:
// NOTE: The following data structures are implemented to record instruction
// targets. Separate data structures are used instead of aggregating the
// target information to minimize the amount of memory allocated
// per instruction - given the ratio of control flow instructions is
// not high, in general. However it is important to populate the target
// information during binary parse time AND is not duplicated.
// A sequential list of source MCInsts or 32-bit data with corresponding index
// Iteration over std::map contents is in non-descending order of keys. So,
// the order in the map is guaranteed to be the order of instructions in the
// insertion order i.e., code stream order.
std::map<uint64_t, MCInstOrData> mcInstMap;
// All targets recorded in a set to avoid duplicate entries
std::set<uint64_t> targetIndices;
// A map of MCInst index, mci, to MachineBasicBlock number, mbbnum. The first
// instruction of MachineBasicBlock number mbbnum is the MachineInstr
// representation of the MCinst at the index, mci
std::map<uint64_t, uint64_t> mcInstToMBBNum;
std::map<uint64_t, std::vector<uint64_t>> MBBNumToMCInstTargetsMap;
MachineInstr *RaiseMCInst(const MCInstrInfo &, MachineFunction &, MCInst,
uint64_t);
// Start and End offsets of the array of MCInsts in mcInstVector;
uint64_t FuncStart;
uint64_t FuncEnd;
// Flag to indicate that the mcInstVector includes data (or uint32_ sized
// quantities that the disassembler was unable to recognize as instrictions
// and are considered data
bool dataInCode;
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_MCINSTRAISER_H

tools/llvm-mctoll/MCInstRaiser.cpp

  • This file was added.
//===-- MCInstRaiser.cpp - Binary raiser utility llvm-mctoll --------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the implementation of MCInstrRaiser class for use by
// llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#include "MCInstRaiser.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/Support/raw_ostream.h"
void MCInstRaiser::buildCFG(MachineFunction &MF, const MCInstrAnalysis *MIA,
const MCInstrInfo *MII) {
bool PrintAll =
(cl::getRegisteredOptions()["print-after-all"]->getNumOccurrences() > 0);
if (PrintAll) {
outs() << "Running buildCFG\n";
}
// Set the first instruction index as the entry of current MBB
// Walk the mcInstMap
// a) if the current instruction is a target instruction
// record the (entry, current MBB) pair
// create a new MBB
// set current instruction index as entry of current MBB
// b) add raised MachineInstr to current MBB.
auto targetIndicesEnd = targetIndices.end();
uint64_t curMBBEntryInstIndex;
for (auto mcInstorDataIter = mcInstMap.begin();
mcInstorDataIter != mcInstMap.end(); mcInstorDataIter++) {
uint64_t mcInstIndex = mcInstorDataIter->first;
MCInstOrData mcInstorData = mcInstorDataIter->second;
// If the current mcInst is a target of some instruction,
// i) record the target of previous instruction and fall-through as
// needed.
// ii) start a new MachineBasicBlock
if (targetIndices.find(mcInstIndex) != targetIndicesEnd) {
// Create a map of curMBBEntryInstIndex to the current
// MachineBasicBlock for use later to create control flow edges
// - except when creating the first MBB.
if (MF.size()) {
// Find the target MCInst indices of the previous MCInst
uint64_t prevMCInstIndex = std::prev(mcInstorDataIter)->first;
MCInstOrData prevTextSecBytes = std::prev(mcInstorDataIter)->second;
std::vector<uint64_t> prevMCInstTargets;
// If handling a mcInst
if (mcInstorData.is_mcInst()) {
MCInst mcInst = mcInstorData.get_mcInst();
// If this instruction is preceeded by mcInst
if (prevTextSecBytes.is_mcInst()) {
MCInst prevMCInst = prevTextSecBytes.get_mcInst();
// If previous MCInst is a branch
if (MIA->isBranch(prevMCInst)) {
uint64_t Target;
// Get its target
if (MIA->evaluateBranch(prevMCInst, prevMCInstIndex,
(mcInstIndex - prevMCInstIndex),
Target)) {
// Record its target if it is within the function start
// and function end. Branch instructions with such
// targets are - for now - treated not to be instructions
// but most likely data bytes embedded in instruction stream.
// TODO: How to handle any branches out of these bounds?
// Does such a situation exist?
if ((Target >= FuncStart) && (Target <= FuncEnd)) {
prevMCInstTargets.push_back(Target);
// If previous instruction is a conditional branch, the
// next instruction is also a target
if (MIA->isConditionalBranch(prevMCInst)) {
if ((mcInstIndex >= FuncStart) &&
(mcInstIndex <= FuncEnd)) {
prevMCInstTargets.push_back(mcInstIndex);
}
}
}
}
}
// Previous MCInst is not a branch. So, current instruction is a
// target
else {
if ((mcInstIndex >= FuncStart) && (mcInstIndex <= FuncEnd)) {
prevMCInstTargets.push_back(mcInstIndex);
}
}
// Add to MBB -> targets map
MBBNumToMCInstTargetsMap.insert(
std::make_pair(MF.back().getNumber(), prevMCInstTargets));
mcInstToMBBNum.insert(
std::make_pair(curMBBEntryInstIndex, MF.back().getNumber()));
} else {
// This is preceded by data. Note that this mcInst is a target.
// So need to start a new basic block
// Add to MBB -> targets map
MBBNumToMCInstTargetsMap.insert(
std::make_pair(MF.back().getNumber(), prevMCInstTargets));
mcInstToMBBNum.insert(
std::make_pair(curMBBEntryInstIndex, MF.back().getNumber()));
}
}
}
// Add the new MBB to MachineFunction
if (mcInstorData.is_mcInst()) {
MF.push_back(MF.CreateMachineBasicBlock());
curMBBEntryInstIndex = mcInstIndex;
}
}
if (mcInstorData.is_mcInst()) {
// add raised MachineInstr to current MBB.
MF.back().push_back(
RaiseMCInst(*MII, MF, mcInstorData.get_mcInst(), mcInstIndex));
}
}
// Add the entry intruction -> MBB map entry for the last MBB
if (MF.size()) {
MBBNumToMCInstTargetsMap.insert(
std::make_pair(MF.back().getNumber(), std::vector<uint64_t>()));
mcInstToMBBNum.insert(
std::make_pair(curMBBEntryInstIndex, MF.back().getNumber()));
}
// Walk all MachineBasicBlocks in MF to add control flow edges
unsigned mbbCount = MF.getNumBlockIDs();
for (unsigned mbbIndex = 0; mbbIndex < mbbCount; mbbIndex++) {
// Get the MBB
MachineBasicBlock *currentMBB = MF.getBlockNumbered(mbbIndex);
std::map<uint64_t, std::vector<uint64_t>>::iterator iter =
MBBNumToMCInstTargetsMap.find(mbbIndex);
assert(iter != MBBNumToMCInstTargetsMap.end());
std::vector<uint64_t> targetMCInstIndices = iter->second;
for (auto mbbMCInstTgt : targetMCInstIndices) {
std::map<uint64_t, uint64_t>::iterator tgtIter =
mcInstToMBBNum.find(mbbMCInstTgt);
// If the target is not found, it could be outside the function
// being constructed.
// TODO: Need to keep track of all such targets and link them in
// a later global pass over all MachineFunctions of the module.
if (tgtIter == mcInstToMBBNum.end()) {
outs() << "**** Warning : Index ";
outs().write_hex(mbbMCInstTgt);
outs() << " not found\n";
// assert(0);
} else {
MachineBasicBlock *succ = MF.getBlockNumbered(tgtIter->second);
currentMBB->addSuccessorWithoutProb(succ);
}
}
}
// Print the Machine function (which contains the reconstructed
// MachineBasicBlocks.
if (PrintAll) {
MF.dump();
}
}
MachineInstr *MCInstRaiser::RaiseMCInst(const MCInstrInfo &mcInstrInfo,
MachineFunction &machineFunction,
MCInst mcInst, uint64_t mcInstIndex) {
// Construct MachineInstr that is the raised abstraction of MCInstr
const MCInstrDesc &mcInstrDesc = mcInstrInfo.get(mcInst.getOpcode());
DebugLoc *debugLoc = new DebugLoc();
MachineInstrBuilder builder =
BuildMI(machineFunction, *debugLoc, mcInstrDesc);
const unsigned int defCount = mcInstrDesc.getNumDefs();
// Get the number of declared MachineOperands for this
// MachineInstruction and add them to the MachineInstr being
// constructed. Any implicitDefs or implicitDefs would already have
// been added while MachineInstr is created during the construction
// of builder object above.
const unsigned int numOperands = mcInstrDesc.getNumOperands();
for (unsigned int indx = 0; indx < numOperands; indx++) {
// Raise operand
MCOperand mcOperand = mcInst.getOperand(indx);
if (mcOperand.isImm()) {
builder.addImm(mcOperand.getImm());
} else if (mcOperand.isReg()) {
// The first defCount operands are defines (i.e., out operands).
if (indx < defCount) {
builder.addDef(mcOperand.getReg());
} else {
builder.addUse(mcOperand.getReg());
}
} else {
outs() << "**** Unhandled Operand : ";
mcOperand.dump();
}
}
LLVMContext &C = machineFunction.getFunction().getContext();
// Creation of MDNode representing Metadata with mcInstIndex may be done using
// the following couple of lines of code. But I just wanted to spell it out
// for better understanding.
// MDNode* temp_N = MDNode::get(C, ConstantAsMetadata::get(ConstantInt::get(C,
// llvm::APInt(64,
// mcInstIndex,
// false))));
// MDNode* N = MDNode::get(C, temp_N);
// Create arbitrary precision
// integer
llvm::APInt ArbPrecInt(64, mcInstIndex, false);
// Create ConstantAsMetadata
ConstantAsMetadata *CMD =
ConstantAsMetadata::get(ConstantInt::get(C, ArbPrecInt));
// MDNode* temp_N = MDNode::get(C, CMD);
MDNode *N = MDNode::get(C, CMD);
builder.addMetadata(N);
return builder.getInstr();
}
void MCInstRaiser::dump() const {
for (auto in : mcInstMap) {
outs() << in.first << " : ";
in.second.dump();
}
}
bool MCInstRaiser::adjustFuncEnd(uint64_t n) {
// NOTE: At present it appears that we only need it to increase the function
// end index.
if (FuncEnd > n) {
return false;
}
FuncEnd = n;
return true;
}
void MCInstRaiser::addMCInstOrData(uint64_t index, MCInstOrData mcInst) {
// Set dataInCode flag as appropriate
if (mcInst.is_data() && !dataInCode) {
dataInCode = true;
}
mcInstMap.insert(std::make_pair(index, mcInst));
}

tools/llvm-mctoll/MachODump.cpp

  • This file was added.
This file has a very large number of changes (9,596 lines). Show File Contents

tools/llvm-mctoll/MachineFunctionRaiser.h

  • This file was added.
//===-- MachineFunctionRaiser.h - Binary raiser utility llvm-mctoll -------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the MachineFunctionRaiser class used
// by llvm-mctoll. This class encapsulates the context in which an assembly
// function is raised.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_FUNCTIONRAISER_H
#define LLVM_TOOLS_LLVM_MCTOLL_FUNCTIONRAISER_H
#include "MachineInstructionRaiser.h"
#include "ModuleRaiser.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/MC/MCInstrAnalysis.h"
#include "llvm/MC/MCInstrInfo.h"
using namespace llvm;
using IndexedData32 = std::pair<uint64_t, uint32_t>;
class MachineFunctionRaiser {
public:
MachineFunctionRaiser(Module &m, MachineFunction &mf, const ModuleRaiser *mr,
uint64_t start, uint64_t end)
: MF(mf), module(m), MR(mr) {
init(start, end);
// The new MachineFunction is not in SSA form, yet
MF.getProperties().reset(MachineFunctionProperties::Property::IsSSA);
};
bool runRaiserPasses();
MachineFunction &getMachineFunction() const { return MF; }
// Getters
MCInstRaiser *getMCInstRaiser() { return mcInstRaiser; }
Module &getModule() { return module; }
MachineInstructionRaiser *getMachineInstrRaiser() {
return machineInstRaiser;
}
Function *getRaisedFunction() {
return machineInstRaiser->getRaisedFunction();
}
const ModuleRaiser *getModuleRaiser() { return MR; }
virtual ~MachineFunctionRaiser() {
delete mcInstRaiser;
}
private:
MachineFunction &MF;
Module &module;
// Data members built and used by this class
MCInstRaiser *mcInstRaiser;
MachineInstructionRaiser *machineInstRaiser;
// A vector of data blobs found in the instruction stream
// of this function. A data blob is a sequence of data bytes.
// Multiple such data blobs may be found while disassembling
// the instruction stream of a function symbol.
std::vector<IndexedData32> dataBlobVector;
const ModuleRaiser *MR;
// Functions
void init(uint64_t funcStart, uint64_t funcEnd);
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_FUNCTIONRAISER_H

tools/llvm-mctoll/MachineFunctionRaiser.cpp

  • This file was added.
//===-- MachineFunctionRaiser.cpp - Binary raiser utility llvm-mctoll -----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the implementaion of MachineFunctionRaiser class for use
// by llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#include "MachineFunctionRaiser.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Target/TargetMachine.h"
#ifdef __cplusplus
extern "C" {
#endif
// ARM Raiser passes
MachineInstructionRaiser *
InitializeARMMachineInstructionRaiser(MachineFunction &machFunc, Module &m,
const ModuleRaiser *mr,
MCInstRaiser *mcir);
// X86 Raiser passes
MachineInstructionRaiser *
InitializeX86MachineInstructionRaiser(MachineFunction &machFunc, Module &m,
const ModuleRaiser *mr,
MCInstRaiser *mcir);
#ifdef __cplusplus
}
#endif
void MachineFunctionRaiser::init(uint64_t start, uint64_t end) {
mcInstRaiser = new MCInstRaiser(start, end);
machineInstRaiser = nullptr;
auto arch = MR->getTargetMachine()->getTargetTriple().getArch();
// Double check supported architecture.
if (!MR->isSupportedArch()) {
outs() << arch << "Unsupported architecture\n";
return;
}
switch (arch) {
case Triple::x86_64:
machineInstRaiser =
InitializeX86MachineInstructionRaiser(MF, module, MR, mcInstRaiser);
break;
case Triple::arm:
machineInstRaiser =
InitializeARMMachineInstructionRaiser(MF, module, MR, mcInstRaiser);
break;
// Add default case to pacify the compiler warnings.
default:
outs() << "\n" << arch << " not yet supported for raising\n";
}
}
bool MachineFunctionRaiser::runRaiserPasses() {
bool success = false;
// Do not run raise binaries of an unsupported architecture.
if (!MR->isSupportedArch())
return false;
// Raise MCInst to MachineInstr and Build CFG
if (machineInstRaiser != nullptr) {
// Raise MachineInstr to Instruction
success = machineInstRaiser->raise();
}
return success;
}
/* NOTE : The following ModuleRaiser class functions are defined here as they
* reference MachineFunctionRaiser class that has a forward declaration in
* ModuleRaiser.h.
*/
// Create a new MachineFunctionRaiser object and add it to the list of
// MachineFunction raiser objects of this module.
MachineFunctionRaiser *ModuleRaiser::CreateAndAddMachineFunctionRaiser(
Function *f, const ModuleRaiser *mr, uint64_t start, uint64_t end) {
MachineFunctionRaiser *mfRaiser = new MachineFunctionRaiser(
M, mr->getMachineModuleInfo()->getOrCreateMachineFunction(*f), mr, start,
end);
mfRaiserVector.push_back(mfRaiser);
return mfRaiser;
}
Function *ModuleRaiser::getFunctionAt(uint64_t Index) const {
int64_t TextSecAddr = getTextSectionAddress();
for (auto MFR : mfRaiserVector) {
if ((MFR->getMCInstRaiser()->getFuncStart() + TextSecAddr) == Index) {
return MFR->getRaisedFunction();
}
}
return nullptr;
}
const RelocationRef *ModuleRaiser::getDynRelocAtOffset(uint64_t Loc) const {
if (DynRelocs.empty()) {
return nullptr;
}
auto relocIter = std::find_if(
DynRelocs.begin(), DynRelocs.end(),
[Loc](const RelocationRef &a) -> bool { return (a.getOffset() == Loc); });
if (relocIter != DynRelocs.end()) {
return &(*relocIter);
} else {
return nullptr;
}
}
// Return relocation whose offset is in the range [Index, Index+Size)
const RelocationRef *ModuleRaiser::getTextRelocAtOffset(uint64_t Index,
uint64_t Size) const {
if (TextRelocs.empty()) {
return nullptr;
}
auto relocIter = std::find_if(TextRelocs.begin(), TextRelocs.end(),
[Index, Size](const RelocationRef &a) -> bool {
return ((a.getOffset() >= Index) &&
(a.getOffset() < (Index + Size)));
});
if (relocIter != TextRelocs.end()) {
return &(*relocIter);
} else {
return nullptr;
}
}
Function *ModuleRaiser::getCalledFunctionUsingTextReloc(uint64_t Loc,
uint64_t Size) const {
// Find the text relocation with offset in the range [Loc, Loc+Size)
const RelocationRef *textReloc = getTextRelocAtOffset(Loc, Loc + Size);
if (textReloc != nullptr) {
Expected<StringRef> sym = textReloc->getSymbol()->getName();
assert(sym && "Failed to find call target symbol");
for (auto MFR : mfRaiserVector) {
Function *FP = MFR->getRaisedFunction();
assert(FP && "Unexpected null function pointer encountered");
if (sym->equals(FP->getName()))
return FP;
}
}
return nullptr;
}
bool ModuleRaiser::runMachineFunctionPasses() {
bool success = true;
// For each of the functions, run passes to
// set up for instruction raising.
for (auto MFR : mfRaiserVector) {
// 1. Build CFG
MCInstRaiser *MCIR = MFR->getMCInstRaiser();
// Populates the MachineFunction with CFG.
MCIR->buildCFG(MFR->getMachineFunction(), MIA, MII);
// 2. Construct function prototype.
// Knowing the function prototypes prior to raising the instructions
// facilitates raising of call instructions whose targets are within
// the current module.
// TODO : Adjust this when raising multiple modules.
Function *RF = MFR->getRaisedFunction();
if (RF == nullptr) {
FunctionType *FT =
MFR->getMachineInstrRaiser()->getRaisedFunctionPrototype();
assert(FT != nullptr && "Failed to build function prototype");
}
}
// Run instruction raiser passes.
for (auto MFR : mfRaiserVector) {
success |= MFR->runRaiserPasses();
}
return success;
}
// Get the MachineFunction associated with the placeholder
// function corresponding to raised function.
MachineFunction *ModuleRaiser::getMachineFunction(Function *RF) {
auto V = PlaceholderRaisedFunctionMap.find(RF);
assert(V != PlaceholderRaisedFunctionMap.end() &&
"Failed to find place-holder function");
return MMI->getMachineFunction(*V->getSecond());
}
bool ModuleRaiser::collectTextSectionRelocs(const SectionRef &TextSec) {
// Assuming only one .text section in the binary
assert(TextSectionIndex == -1 &&
"Relocations for .text section already collected");
TextSectionIndex = TextSec.getIndex();
// Find the section whose relocated section index is TextSecIndex.
// That section is the one with relocations corresponding to the
// section with index TextSecIndex.
for (const SectionRef &CandRelocSection : Obj->sections()) {
section_iterator RelocatedSecIter = CandRelocSection.getRelocatedSection();
// If the CandRelocSection has a corresponding relocated section
if (RelocatedSecIter != Obj->section_end()) {
// If the corresponding relocated section is TextSec, CandRelocSection
// is the section with relocation information for TextSec.
if (RelocatedSecIter->getIndex() == (uint64_t)TextSectionIndex) {
for (const RelocationRef &reloc : CandRelocSection.relocations()) {
TextRelocs.push_back(reloc);
}
// Sort the relocations
std::sort(TextRelocs.begin(), TextRelocs.end(),
[](const RelocationRef &a, const RelocationRef &b) -> bool {
return a.getOffset() < b.getOffset();
});
break;
}
}
}
return true;
}
bool ModuleRaiser::collectDynamicRelocations() {
if (!Obj->isELF()) {
return false;
}
const ELF64LEObjectFile *Elf64LEObjFile = dyn_cast<ELF64LEObjectFile>(Obj);
if (!Elf64LEObjFile) {
return false;
}
std::vector<SectionRef> DynRelSec = Obj->dynamic_relocation_sections();
for (const SectionRef &Section : DynRelSec) {
for (const RelocationRef &Reloc : Section.relocations()) {
DynRelocs.push_back(Reloc);
}
}
// Get relocations of .got.plt section from .rela.plt if it exists. I do not
// see an API in ObjectFile class to get at these.
// Find .got.plt and .rela.plt sections Note: A lot of verification and double
// checking done in the following code.
const ELFFile<ELF64LE> *ElfFile = Elf64LEObjFile->getELFFile();
// Find .rela.plt
SectionRef DotGotDotPltSec, DotRelaDotPltSec;
for (const SectionRef Section : Obj->sections()) {
StringRef SecName;
Section.getName(SecName);
if (SecName.equals(".rela.plt")) {
DotRelaDotPltSec = Section;
} else if (SecName.equals(".got.plt")) {
DotGotDotPltSec = Section;
}
}
if (DotRelaDotPltSec.getObject() != nullptr) {
// Do some additional sanity checks
assert((DotGotDotPltSec.getObject() != nullptr) &&
"Failed to find .got.plt section");
auto DotRelaDotPltShdr = ElfFile->getSection(DotRelaDotPltSec.getIndex());
assert(DotRelaDotPltShdr && "Failed to find .rela.plt section");
assert((DotRelaDotPltShdr.get()->sh_info == DotGotDotPltSec.getIndex()) &&
".rela.plt does not refer .got.plt section");
assert((DotRelaDotPltShdr.get()->sh_type == ELF::SHT_RELA) &&
"Unexpected type of section .rela.plt");
for (const RelocationRef &Reloc : DotRelaDotPltSec.relocations()) {
DynRelocs.push_back(Reloc);
}
}
return true;
}
// Return text section address; or -1 if text section is not found
int64_t ModuleRaiser::getTextSectionAddress() const {
if (!Obj->isELF()) {
return -1;
}
assert(TextSectionIndex >= 0 && "Unexpected negative index of text section");
for (SectionRef Sec : Obj->sections()) {
if (Sec.getIndex() == (unsigned)TextSectionIndex) {
return Sec.getAddress();
}
}
assert(false && "Failed to locate text section.");
return -1;
}
const Value *ModuleRaiser::getRODataValueAt(uint64_t offset) const {
Value *V = nullptr;
auto iter = GlobalRODataValues.find(offset);
if (iter != GlobalRODataValues.end()) {
V = iter->second;
}
return V;
}
void ModuleRaiser::addRODataValueAt(Value *v, uint64_t offset) const {
assert((GlobalRODataValues.find(offset) == GlobalRODataValues.end()) &&
"Attempt to insert value for already existing rodata location");
GlobalRODataValues.emplace(offset, v);
return;
}

tools/llvm-mctoll/MachineInstructionRaiser.h

  • This file was added.
//===-- MachineInstructionRaiser.h - Binary raiser utility llvm-mctoll ----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of MachineInstructionRaiser class used
// by llvm-mctoll. This class encapsulates the raising of MachineInstruction
// to LLVM Instruction
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_MACHINEINSTRUCTIONRAISER_H
#define LLVM_TOOLS_LLVM_MCTOLL_MACHINEINSTRUCTIONRAISER_H
#include "MCInstRaiser.h"
#include "ModuleRaiser.h"
#include "llvm/CodeGen/MachineFunction.h"
using namespace llvm;
// Structure holding all necesssary information to raise control
// transfer (i.e., branch) instructions during a post-processing
// phase.
typedef struct {
BasicBlock *CandidateBlock;
// This is the MachineInstr that needs to be raised
const MachineInstr *CandidateMachineInstr;
// A vector of values that could be of use while raising
// CandidateMachineInstr. If it is a call instruction,
// This vector has the Values corresponding to argument
// registers (TODO : need to handles arguments passed on stack)
std::vector<Value *> RegValues;
// Flag to indicate that CandidateMachineInstr has been raised
bool Raised;
} ControlTransferInfo;
class MachineInstructionRaiser {
public:
MachineInstructionRaiser() = delete;
MachineInstructionRaiser(MachineFunction &machFunc, Module &m,
const ModuleRaiser *mr, MCInstRaiser *mcir = nullptr)
: MF(machFunc), raisedFunction(nullptr), mcInstRaiser(mcir), MR(mr),
PrintPass(false) {}
virtual ~MachineInstructionRaiser(){};
virtual bool raise() { return true; };
virtual FunctionType *getRaisedFunctionPrototype() = 0;
virtual int getArgumentNumber(unsigned PReg) = 0;
virtual Value *getRegValue(unsigned PReg) = 0;
virtual bool buildFuncArgTypeVector(const std::set<MCPhysReg> &,
std::vector<Type *> &) = 0;
Function *getRaisedFunction() { return raisedFunction; }
MCInstRaiser *getMCInstRaiser() { return mcInstRaiser; }
std::vector<ControlTransferInfo *> getControlTransferInfo() {
return CTInfo;
};
protected:
MachineFunction &MF;
// This is the Function object that holds the raised abstraction of MF.
// Not the the fucntion associated with MF should not be referenced or
// updated. It was created just to enable the creation of MF.
Function *raisedFunction;
MCInstRaiser *mcInstRaiser;
const ModuleRaiser *MR;
// A vector of information to be used for raising of control transfer
// (i.e., Call and Terminator) instructions.
std::vector<ControlTransferInfo *> CTInfo;
bool PrintPass;
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_MACHINEINSTRUCTIONRAISER_H

tools/llvm-mctoll/ModuleRaiser.h

  • This file was added.
//===-- ModuleRaiser.h - Object file dumping utility for llvm -------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of ModuleRaiser class for use by
// llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_MODULERAISER_H
#define LLVM_TOOLS_LLVM_MCTOLL_MODULERAISER_H
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/MC/MCDisassembler/MCDisassembler.h"
#include "llvm/MC/MCInstrAnalysis.h"
#include "llvm/Object/ObjectFile.h"
#include "llvm/Target/TargetMachine.h"
#include <vector>
using namespace llvm;
using namespace std;
class MachineFunctionRaiser;
using namespace object;
// The ModuleRaiser class encapsulates information needed to raise a given
// module.
class ModuleRaiser {
public:
ModuleRaiser(Module &m, const TargetMachine *tm, MachineModuleInfo *mmi,
const MCInstrAnalysis *mia, const MCInstrInfo *mii,
const ObjectFile *o, MCDisassembler *dis)
: M(m), TM(tm), MMI(mmi), MIA(mia), MII(mii), Obj(o), DisAsm(dis),
TextSectionIndex(-1) {
supportedArch = false;
auto arch = tm->getTargetTriple().getArch();
switch (arch) {
case Triple::x86_64:
supportedArch = true;
break;
case Triple::arm:
supportedArch = true;
break;
default:
outs() << "\n" << arch << " not yet supported for raising\n";
}
// Collect dynamic relocations.
collectDynamicRelocations();
}
// Function to create a MachineFunctionRaiser corresponding to Function f.
// As noted elsewhere (llvm-mctoll.cpp), f is a place holder to allow for
// creation of MachineFunction. The Function object representing raising
// of MachineFunction is accessible by calling getRaisedFunction()
// on the MachineFunctionRaiser object.
MachineFunctionRaiser *CreateAndAddMachineFunctionRaiser(Function *f,
const ModuleRaiser *,
uint64_t start,
uint64_t end);
MachineFunctionRaiser *getCurrentMachineFunctionRaiser() {
if (mfRaiserVector.size() > 0) {
return mfRaiserVector.back();
}
return nullptr;
}
// Insert the map of raised function R to place-holder function PH pointer
// that inturn has the to corresponding MachineFunction.
bool insertPlaceholderRaisedFunctionMap(Function *R, Function *PH) {
auto V = PlaceholderRaisedFunctionMap.insert(std::make_pair(R, PH));
return V.second;
}
bool collectTextSectionRelocs(const SectionRef &);
bool collectDynamicRelocations();
MachineFunction *getMachineFunction(Function *);
// Member getters
Module &getModule() const { return M; }
const TargetMachine *getTargetMachine() const { return TM; }
MachineModuleInfo *getMachineModuleInfo() const { return MMI; }
const MCInstrAnalysis *getMCInstrAnalysis() const { return MIA; }
const MCInstrInfo *getMCInstrInfo() const { return MII; }
const ObjectFile *getObjectFile() const { return Obj; }
const MCDisassembler *getMCDisassembler() const { return DisAsm; }
bool isSupportedArch() const { return supportedArch; }
bool runMachineFunctionPasses();
// Return the Function * corresponding to input binary function with
// start offset equal to that specified as argument.
Function *getFunctionAt(uint64_t) const;
// Return the Function * corresponding to input binary function from
// text relocation record with off set in the range [Loc, Loc+Size].
Function *getCalledFunctionUsingTextReloc(uint64_t Loc, uint64_t Size) const;
// Get dynamic relocation with offset 'O'
const RelocationRef *getDynRelocAtOffset(uint64_t O) const;
// Return text relocation of instruction at index 'I'. 'S' is the size of the
// instruction at index 'I'.
const RelocationRef *getTextRelocAtOffset(uint64_t I, uint64_t S) const;
int64_t getTextSectionAddress() const;
const Value *getRODataValueAt(uint64_t) const;
void addRODataValueAt(Value *, uint64_t) const;
virtual ~ModuleRaiser() {}
private:
// A sequential list of MachineFunctionRaiser objects created
// as the instructions of the input binary are parsed. Each of
// these correspond to a "machine function". A machine function
// corresponds to a sequence of instructions (possibly interspersed
// by data bytes) whose start is denoted by a function symbol in
// the binary.
std::vector<MachineFunctionRaiser *> mfRaiserVector;
// A map of raised function pointer to place-holder function pointer
// that links to the MachineFunction.
DenseMap<Function *, Function *> PlaceholderRaisedFunctionMap;
// Sorted vector of text relocations
std::vector<RelocationRef> TextRelocs;
// Vector of dynamic relocation records
std::vector<RelocationRef> DynRelocs;
// Map of read-only data (i.e., from .rodata) to its corresponding global
// value.
// NOTE: A const version of ModuleRaiser object is constructed during the
// raising process. Making this map mutable since this map is expected to be
// updated throughout the raising process.
mutable std::map<uint64_t, Value *> GlobalRODataValues;
// Commonly used data structures
Module &M;
const TargetMachine *TM;
MachineModuleInfo *MMI;
const MCInstrAnalysis *MIA;
const MCInstrInfo *MII;
bool supportedArch;
const ObjectFile *Obj;
MCDisassembler *DisAsm;
// Index of text section whose instructions are raised
int64_t TextSectionIndex;
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_MODULERAISER_H

tools/llvm-mctoll/README.md

  • This file was added.
# Introduction
Tool to statically (AOT) translate binaries to LLVM IR.
A tool to raise (or lift) compiled binaries to LLVM IR.
The implementation uses disassembly functionality implemented in
llvm-objdump.
# Getting Started (Linux/Mac)
## Building as part of LLVM tree
1. `mkdir $PWD/src && mkdir -p $PWD/build/llvm && cd src`
2. `git clone https://edgetools.visualstudio.com/DefaultCollection/llvm/_git/llvm && pushd llvm && git checkout master && popd`
3. `pushd llvm/tools && git clone https://edgetools.visualstudio.com/DefaultCollection/llvm/_git/clang && git checkout master && popd`
4. `pushd llvm/tools && git clone https://edgetools.visualstudio.com/DefaultCollection/llvm/_git/llvm-mctoll && git checkout master && popd`
7. `cd ../build/llvm`
7. Run cmake command that you usually use to build llvm
8. Run `make llvm-mctoll` or `ninja llvm-mctoll`
## Building as standalone project (not as part of LLVM tree)
(**NOTE** : _Support for this needs to be updated. Please build llvm-mctoll as part of LLVM tree as described above_.)
The source files of this project include LLVM target-specific headers
from the LLVM source directory and LLVM build directory. Hence LLVM
sources need to be downloaded and built. At least, the following LLVM
targets need to be built so that all dependencies of llvm-mctoll are
available prior creating build files for llvm-mctoll (i.e., prior to
running `cmake` on llvm-mctoll tree).
* llc
* llvm-objdump
* llvm-config
Building the targets llc and llvm-objdump will build all the necessary
libraries and include files to enable building of llvm-mctoll.
At present llvm-mctoll is being developed to handle X86_64 and ARM
binaries. So the above targets need to be built at least for these two
targets.
CMake script of llvm-mctoll uses `llvm-config` from the build tree to
discover the following information of the LLVM build used to build
llvm-mctoll.
* assertion mode,
* location of build and object directories,
* location of LLVM source directory
* compiler flags to be used,
* location of cmake script directory
`llvm-config` from the LLVM build directory needs to be specified in the
cmake command that creates build files for llvm-mctoll.
If you also want to run the tests for llvm-mctoll, the following
additional dependencies from LLVM need to be built:
* clang
* count
* not
* FileCheck
Following assumes that llvm build dir is `<llvm-build-dir>` and an
install directory `<install-dir>` of your choice.
1. `mkdir $PWD/src; mkdir -p $PWD/build/llvm-mctoll; cd src`
2. `git clone https://edgetools.visualstudio.com/DefaultCollection/_git/rawbits`
3. `cd ../build/llvm-mctoll`
4. Run cmake command as follows
`cmake -G ["Unix Makefiles"|"Ninja"] -DLLVM_CONFIG_PATH=<llvm-build-dir>/bin/llvm-config -DCMAKE_INSTALL_PREFIX=<install-dir> ../../src/rawbits/llvm-mctoll`
5. Run `make` or `ninja`. Resulting binary `llvm-mctoll` is in current directory.
6. (Optional) Run `make install` or `ninja install`
# Usage instructions:
`llvm-mctoll -d <binary>`
or
To print debug output:
`llvm-mctoll -d -print-after-all <binary>`
To view Pass:
`llvm-mctoll -d -debug-pass=Structure <binary>`
# Current Status
The tool is currently able to raise Linux x86_64 shared libraries and executables with `printf` calls.
TODO :
1. Cleanup llvm-objdump related functionality that is not relevant to this tool.
# Build and Test
Run the tests by invoking 'make check-mctoll' or 'ninja check-mctoll'
# Contribute
TODO: Explain how other users and developers can contribute to make your code better.

tools/llvm-mctoll/WasmDump.cpp

  • This file was added.
//===-- WasmDump.cpp - wasm-specific dumper ---------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// \brief This file implements the wasm-specific dumper for llvm-objdump.
///
//===----------------------------------------------------------------------===//
#include "llvm-mctoll.h"
#include "llvm/Object/Wasm.h"
using namespace llvm;
using namespace object;
void llvm::printWasmFileHeader(const object::ObjectFile *Obj) {
const WasmObjectFile *File = dyn_cast<const WasmObjectFile>(Obj);
outs() << "Program Header:\n";
outs() << "Version: 0x";
outs().write_hex(File->getHeader().Version);
outs() << "\n";
}

tools/llvm-mctoll/X86/CMakeLists.txt

  • This file was added.
include_directories(
${LLVM_MAIN_SRC_DIR}/lib/Target/X86
${LLVM_BINARY_DIR}/lib/Target/X86
${CMAKE_CURRENT_SOURCE_DIR}/..
)
if(NOT LLVM_MCTOLL_BUILT_STANDALONE)
set(LLVM_MCTOLL_DEPS intrinsics_gen X86CommonTableGen)
endif()
add_llvm_library(X86Raiser
X86MachineInstructionRaiser.cpp
DEPENDS
${LLVM_MCTOLL_DEPS}
)

tools/llvm-mctoll/X86/X86AdditionalInstrInfo.h

  • This file was added.
This file has a very large number of changes (14,636 lines). Show File Contents

tools/llvm-mctoll/X86/X86MachineInstructionRaiser.h

  • This file was added.
//==-- X86MachineInstructionRaiser.h - Binary raiser utility llvm-mctoll =====//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of X86MachineInstructionRaiser
// class for use by llvm-mctoll.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_X86_X86MACHINEINSTRUCTIONRAISER_H
#define LLVM_TOOLS_LLVM_MCTOLL_X86_X86MACHINEINSTRUCTIONRAISER_H
#include "MachineInstructionRaiser.h"
#include "X86AdditionalInstrInfo.h"
// X86AddressMode is a struct. So provide a Compare operator.
struct X86AddressModeCompare {
bool operator()(const X86AddressMode &lhs, const X86AddressMode &rhs) const {
return ((lhs.Scale < rhs.Scale) || (lhs.IndexReg < rhs.IndexReg) ||
(lhs.Disp < rhs.Disp));
}
};
using MemRefToFrameIndexMapType =
std::map<X86AddressMode, unsigned int, X86AddressModeCompare>;
using MemRefToFrameIndexMapTypeIter = MemRefToFrameIndexMapType::iterator;
using MBBNumToBBMap = std::map<unsigned int, BasicBlock *>;
class X86MachineInstructionRaiser : public MachineInstructionRaiser {
public:
X86MachineInstructionRaiser() = delete;
X86MachineInstructionRaiser(MachineFunction &machFunc, Module &m,
const ModuleRaiser *mr, MCInstRaiser *mcir);
bool raise();
private:
// Bit positions used for individual status flags of EFLAGS register.
// Note : only those that are currently used are represented here.
enum {
EFLAGS_CF = 0,
EFLAGS_PF = 2,
EFLAGS_AF = 4,
EFLAGS_ZF = 6,
EFLAGS_SF = 7,
EFLAGS_OF = 11,
EFLAGS_UNDEFINED = 32
};
// Map of physical registers -> virtual registers
std::map<unsigned int, unsigned int> physToVirtMap;
// Map of physical registers -> Value * created
std::map<unsigned int, Value *> physToValueMap;
// std::stack<Value *> FPURegisterStack;
static const uint8_t FPUSTACK_SZ = 8;
struct {
int8_t TOP;
Value *Regs[FPUSTACK_SZ];
} FPUStack;
// A map of memory references in the MachineFunction code to stack
// frame slot index
MemRefToFrameIndexMapType memRefToFrameIndexMap;
// A map of memory references in the MachineFunction code to
// global variables
// A map of MachineFunctionBlock number to BasicBlock *
MBBNumToBBMap mbbToBBMap;
// Commonly used LLVM data structures during this phase
MachineRegisterInfo &machineRegInfo;
const X86Subtarget &x86TargetInfo;
const X86InstrInfo *x86InstrInfo;
const X86RegisterInfo *x86RegisterInfo;
bool raiseMachineFunction();
FunctionType *getRaisedFunctionPrototype();
// This raises MachineInstr to MachineInstruction
bool raiseMachineInstr(MachineInstr &, BasicBlock *);
// Cleanup MachineBasicBlocks
bool deleteNOOPInstrMI(MachineBasicBlock &, MachineBasicBlock::iterator);
bool deleteNOOPInstrMF();
// Raise specific classes of instructions
bool raisePushInstruction(const MachineInstr &);
bool raisePopInstruction(const MachineInstr &);
bool raiseMemRefMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseReturnMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseGenericMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseConvertBWWDDQMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseConvertWDDQQOMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseLEAMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseMoveRegToRegMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseMoveImmToRegMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseBinaryOpRegToRegMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseBinaryOpImmToRegMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseSetCCMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseCompareMachineInstr(const MachineInstr &, BasicBlock *, bool,
Value *);
bool raiseCallMachineInstr(const MachineInstr &, BasicBlock *);
bool raiseMoveToMemInstr(const MachineInstr &, BasicBlock *, Value *);
bool raiseMoveFromMemInstr(const MachineInstr &, BasicBlock *, Value *);
bool raiseBinaryOpMemToRegInstr(const MachineInstr &, BasicBlock *, Value *);
bool raiseDivideInstr(const MachineInstr &, BasicBlock *, Value *);
bool raiseLoadIntToFloatRegInstr(const MachineInstr &, BasicBlock *, Value *);
bool raiseStoreIntToFloatRegInstr(const MachineInstr &, BasicBlock *,
Value *);
bool raiseFPURegisterOpInstr(const MachineInstr &, BasicBlock *);
bool raiseBranchMachineInstrs();
bool raiseDirectBranchMachineInstr(ControlTransferInfo *);
bool raiseIndirectBranchMachineInstr(ControlTransferInfo *);
// Method to record information that is used in a second pass
// to raise control transfer instructions in a second pass.
bool recordMachineInstrInfo(const MachineInstr &, BasicBlock *);
bool insertAllocaInEntryBlock(Instruction *alloca);
// FPU Stack access functions
void FPURegisterStackPush(Value *);
void FPURegisterStackPop();
Value *FPURegisterStackGetValueAt(int8_t);
void FPURegisterStackSetValueAt(int8_t, Value *);
Value *FPURegisterStackTop();
// Helper functions
int getMemoryRefOpIndex(const MachineInstr &);
Value *getGlobalVariableValueAt(const MachineInstr &, uint64_t);
const Value *getOrCreateGlobalRODataValueAtAt(const MachineInstr &, uint64_t);
Value *getMemoryAddressExprValue(const MachineInstr &, BasicBlock *);
Value *createPCRelativeAccesssValue(const MachineInstr &, BasicBlock *);
bool changePhysRegToVirtReg(MachineInstr &);
unsigned int find64BitSuperReg(unsigned int);
Value *findPhysRegSSAValue(unsigned int);
Value *matchSSAValueToSrcRegSize(const MachineInstr &mi, unsigned SrcOpIndex,
BasicBlock *curBlock);
std::pair<std::map<unsigned int, Value *>::iterator, bool>
updatePhysRegSSAValue(unsigned int PhysReg, Value *);
Type *getFunctionReturnType();
Type *getReturnTypeFromMBB(MachineBasicBlock &MBB);
Function *getTargetFunctionAtPLTOffset(const MachineInstr &, uint64_t);
Value *getStackAllocatedValue(const MachineInstr &, BasicBlock *, int);
int getArgumentNumber(unsigned PReg);
bool buildFuncArgTypeVector(const std::set<MCPhysReg> &,
std::vector<Type *> &);
Value *getRegValue(unsigned);
};
#endif // LLVM_TOOLS_LLVM_MCTOLL_X86_X86ELIMINATEPROLOGEPILOG_H

tools/llvm-mctoll/X86/X86MachineInstructionRaiser.cpp

  • This file was added.
This file has a very large number of changes (4,091 lines). Show File Contents

tools/llvm-mctoll/llvm-mctoll.h

  • This file was added.
//===---- llvm-mctoll.h - Binary raiser utility llvm-mctoll ---------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_MCTOLL_LLVM_MCTOLL_H
#define LLVM_TOOLS_LLVM_MCTOLL_LLVM_MCTOLL_H
#include "llvm/DebugInfo/DIContext.h"
#include "llvm/Object/Archive.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/DataTypes.h"
namespace llvm {
class StringRef;
namespace object {
class COFFObjectFile;
class COFFImportFile;
class MachOObjectFile;
class ObjectFile;
class Archive;
class RelocationRef;
} // namespace object
extern cl::opt<std::string> TripleName;
extern cl::opt<std::string> ArchName;
extern cl::list<std::string> FilterSections;
extern cl::list<std::string> FilterFunctions;
extern cl::opt<bool> Disassemble;
// extern cl::opt<bool> DisassembleAll;
extern cl::opt<bool> NoShowRawInsn;
extern cl::opt<bool> NoLeadingAddr;
extern cl::opt<bool> PrivateHeaders;
extern cl::opt<bool> FirstPrivateHeader;
extern cl::opt<bool> ExportsTrie;
extern cl::opt<bool> Rebase;
extern cl::opt<bool> Bind;
extern cl::opt<bool> LazyBind;
extern cl::opt<bool> WeakBind;
extern cl::opt<bool> RawClangAST;
extern cl::opt<bool> UniversalHeaders;
extern cl::opt<bool> ArchiveHeaders;
extern cl::opt<bool> IndirectSymbols;
extern cl::opt<bool> DataInCode;
extern cl::opt<bool> LinkOptHints;
extern cl::opt<bool> InfoPlist;
extern cl::opt<bool> DylibsUsed;
extern cl::opt<bool> DylibId;
extern cl::opt<bool> ObjcMetaData;
extern cl::opt<std::string> DisSymName;
extern cl::opt<bool> NonVerbose;
extern cl::opt<bool> Relocations;
extern cl::opt<bool> SectionHeaders;
extern cl::opt<bool> SectionContents;
extern cl::opt<bool> SymbolTable;
extern cl::opt<bool> UnwindInfo;
extern cl::opt<bool> PrintImmHex;
extern cl::opt<DIDumpType> DwarfDumpType;
// Various helper functions.
void error(std::error_code ec);
bool RelocAddressLess(object::RelocationRef a, object::RelocationRef b);
void ParseInputMachO(StringRef Filename);
void printCOFFUnwindInfo(const object::COFFObjectFile *o);
void printMachOUnwindInfo(const object::MachOObjectFile *o);
void printMachOExportsTrie(const object::MachOObjectFile *o);
void printMachORebaseTable(object::MachOObjectFile *o);
void printMachOBindTable(object::MachOObjectFile *o);
void printMachOLazyBindTable(object::MachOObjectFile *o);
void printMachOWeakBindTable(object::MachOObjectFile *o);
void printELFFileHeader(const object::ObjectFile *o);
void printCOFFFileHeader(const object::ObjectFile *o);
void printCOFFSymbolTable(const object::COFFImportFile *i);
void printCOFFSymbolTable(const object::COFFObjectFile *o);
void printMachOFileHeader(const object::ObjectFile *o);
void printMachOLoadCommands(const object::ObjectFile *o);
void printWasmFileHeader(const object::ObjectFile *o);
void printExportsTrie(const object::ObjectFile *o);
void printRebaseTable(object::ObjectFile *o);
void printBindTable(object::ObjectFile *o);
void printLazyBindTable(object::ObjectFile *o);
void printWeakBindTable(object::ObjectFile *o);
void printRawClangAST(const object::ObjectFile *o);
void PrintRelocations(const object::ObjectFile *o);
void PrintSectionHeaders(const object::ObjectFile *o);
void PrintSectionContents(const object::ObjectFile *o);
void PrintSymbolTable(const object::ObjectFile *o, StringRef ArchiveName,
StringRef ArchitectureName = StringRef());
LLVM_ATTRIBUTE_NORETURN void error(Twine Message);
LLVM_ATTRIBUTE_NORETURN void report_error(StringRef File, Twine Message);
LLVM_ATTRIBUTE_NORETURN void report_error(StringRef File, std::error_code EC);
LLVM_ATTRIBUTE_NORETURN void report_error(StringRef File, llvm::Error E);
LLVM_ATTRIBUTE_NORETURN void
report_error(StringRef FileName, StringRef ArchiveName, llvm::Error E,
StringRef ArchitectureName = StringRef());
LLVM_ATTRIBUTE_NORETURN void
report_error(StringRef ArchiveName, const object::Archive::Child &C,
llvm::Error E, StringRef ArchitectureName = StringRef());
} // end namespace llvm
#endif // LLVM_TOOLS_LLVM_MCTOLL_LLVM_MCTOLL_H

tools/llvm-mctoll/llvm-mctoll.cpp

  • This file was added.
//===-- llvm-mctoll.cpp - Object file dumping utility for llvm -----------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
//
// This program is a utility that converts a binary to LLVM IR (.ll file)
//
//===----------------------------------------------------------------------===//
#include "llvm-mctoll.h"
#include "EmitRaisedOutputPass.h"
#include "MCInstOrData.h"
#include "MachineFunctionRaiser.h"
#include "ModuleRaiser.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/Triple.h"
#include "llvm/Bitcode/BitcodeWriter.h"
#include "llvm/Bitcode/BitcodeWriterPass.h"
#include "llvm/CodeGen/FaultMaps.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/CodeGen/TargetPassConfig.h"
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
#include "llvm/DebugInfo/Symbolize/Symbolize.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRPrintingPasses.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCDisassembler/MCDisassembler.h"
#include "llvm/MC/MCDisassembler/MCRelocationInfo.h"
#include "llvm/MC/MCInstPrinter.h"
#include "llvm/MC/MCInstrAnalysis.h"
#include "llvm/MC/MCInstrInfo.h"
#include "llvm/MC/MCObjectFileInfo.h"
#include "llvm/MC/MCRegisterInfo.h"
#include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/Object/Archive.h"
#include "llvm/Object/COFF.h"
#include "llvm/Object/COFFImportFile.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Object/MachO.h"
#include "llvm/Object/ObjectFile.h"
#include "llvm/Object/Wasm.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/GraphWriter.h"
#include "llvm/Support/Host.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/Signals.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Support/ToolOutputFile.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
#include <algorithm>
#include <cctype>
#include <cstring>
#include <set>
#include <system_error>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace llvm;
using namespace object;
static cl::OptionCategory LLVMMCToLLCategory("llvm-mctoll options");
static cl::list<std::string> InputFilenames(cl::Positional,
cl::desc("<input object files>"),
cl::ZeroOrMore);
static cl::opt<std::string> OutputFilename("o", cl::desc("Output filename"),
cl::value_desc("filename"),
cl::cat(LLVMMCToLLCategory),
cl::NotHidden);
cl::opt<std::string>
MCPU("mcpu",
cl::desc("Target a specific cpu type (-mcpu=help for details)"),
cl::value_desc("cpu-name"), cl::init(""));
cl::list<std::string>
MAttrs("mattr", cl::CommaSeparated,
cl::desc("Target specific attributes (-mattr=help for details)"),
cl::value_desc("a1,+a2,-a3,..."));
// Output file type. Default is binary bitcode.
cl::opt<TargetMachine::CodeGenFileType> OutputFormat(
"output-format", cl::init(TargetMachine::CGFT_AssemblyFile),
cl::desc("Output format (default: binary bitcode):"),
cl::values(clEnumValN(TargetMachine::CGFT_AssemblyFile, "ll",
"Emit llvm text bitcode ('.ll') file"),
clEnumValN(TargetMachine::CGFT_ObjectFile, "bc",
"Emit llvm binary bitcode ('.bc') file"),
clEnumValN(TargetMachine::CGFT_Null, "null",
"Emit nothing, for performance testing")),
cl::cat(LLVMMCToLLCategory), cl::NotHidden);
cl::opt<bool> llvm::Disassemble("raise", cl::desc("Raise machine instruction"),
cl::cat(LLVMMCToLLCategory), cl::NotHidden);
cl::alias Disassembled("d", cl::desc("Alias for -raise"),
cl::aliasopt(Disassemble), cl::cat(LLVMMCToLLCategory),
cl::NotHidden);
cl::opt<bool>
llvm::Relocations("r",
cl::desc("Display the relocation entries in the file"));
cl::opt<bool> llvm::SymbolTable("t", cl::desc("Display the symbol table"));
cl::opt<bool> llvm::ExportsTrie("exports-trie",
cl::desc("Display mach-o exported symbols"));
cl::opt<bool> llvm::Rebase("rebase", cl::desc("Display mach-o rebasing info"));
cl::opt<bool> llvm::Bind("bind", cl::desc("Display mach-o binding info"));
cl::opt<bool> llvm::LazyBind("lazy-bind",
cl::desc("Display mach-o lazy binding info"));
cl::opt<bool> llvm::WeakBind("weak-bind",
cl::desc("Display mach-o weak binding info"));
cl::opt<bool> llvm::RawClangAST(
"raw-clang-ast",
cl::desc("Dump the raw binary contents of the clang AST section"));
static cl::opt<bool>
MachOOpt("macho", cl::desc("Use MachO specific object file parser"));
static cl::alias MachOm("m", cl::desc("Alias for --macho"),
cl::aliasopt(MachOOpt));
static cl::opt<bool> NoVerify("disable-verify", cl::Hidden,
cl::desc("Do not verify input module"));
cl::opt<std::string>
llvm::TripleName("triple", cl::desc("Target triple to disassemble for, "
"see -version for available targets"));
cl::opt<std::string>
llvm::ArchName("arch-name", cl::desc("Target arch to disassemble for, "
"see -version for available targets"));
cl::opt<bool> llvm::SectionHeaders("section-headers",
cl::desc("Display summaries of the "
"headers for each section."));
static cl::alias SectionHeadersShort("headers",
cl::desc("Alias for --section-headers"),
cl::aliasopt(SectionHeaders));
static cl::alias SectionHeadersShorter("h",
cl::desc("Alias for --section-headers"),
cl::aliasopt(SectionHeaders));
cl::list<std::string>
llvm::FilterSections("section",
cl::desc("Operate on the specified sections only. "
"With -macho dump segment,section"));
cl::list<std::string>
llvm::FilterFunctions("function",
cl::desc("Operate on the specified functions only. "),
cl::cat(LLVMMCToLLCategory), cl::NotHidden);
cl::alias static FilterSectionsj("j", cl::desc("Alias for --section"),
cl::aliasopt(llvm::FilterSections));
cl::opt<bool> llvm::NoShowRawInsn("no-show-raw-insn",
cl::desc("When disassembling "
"instructions, do not print "
"the instruction bytes."));
cl::opt<bool> llvm::NoLeadingAddr("no-leading-addr",
cl::desc("Print no leading address"));
cl::opt<bool> llvm::UnwindInfo("unwind-info",
cl::desc("Display unwind information"));
static cl::alias UnwindInfoShort("u", cl::desc("Alias for --unwind-info"),
cl::aliasopt(UnwindInfo));
cl::opt<bool>
llvm::PrivateHeaders("private-headers",
cl::desc("Display format specific file headers"));
cl::opt<bool> llvm::FirstPrivateHeader(
"private-header", cl::desc("Display only the first format specific file "
"header"));
static cl::alias PrivateHeadersShort("p",
cl::desc("Alias for --private-headers"),
cl::aliasopt(PrivateHeaders));
cl::opt<bool>
llvm::PrintImmHex("print-imm-hex",
cl::desc("Use hex format for immediate values"));
cl::opt<bool> PrintFaultMaps("fault-map-section",
cl::desc("Display contents of faultmap section"));
cl::opt<bool> PrintSource(
"source",
cl::desc(
"Display source inlined with disassembly. Implies disassmble object"));
cl::alias PrintSourceShort("S", cl::desc("Alias for -source"),
cl::aliasopt(PrintSource));
cl::opt<bool> PrintLines("line-numbers",
cl::desc("Display source line numbers with "
"disassembly. Implies disassemble object"));
cl::alias PrintLinesShort("l", cl::desc("Alias for -line-numbers"),
cl::aliasopt(PrintLines));
cl::opt<unsigned long long>
StartAddress("start-address", cl::desc("Disassemble beginning at address"),
cl::value_desc("address"), cl::init(0));
cl::opt<unsigned long long> StopAddress("stop-address",
cl::desc("Stop disassembly at address"),
cl::value_desc("address"),
cl::init(UINT64_MAX));
namespace {
static ManagedStatic<std::vector<std::string>> RunPassNames;
struct RunPassOption {
void operator=(const std::string &Val) const {
if (Val.empty())
return;
SmallVector<StringRef, 8> PassNames;
StringRef(Val).split(PassNames, ',', -1, false);
for (auto PassName : PassNames)
RunPassNames->push_back(PassName);
}
};
} // namespace
static RunPassOption RunPassOpt;
static cl::opt<RunPassOption, true, cl::parser<std::string>> RunPass(
"run-pass",
cl::desc("Run compiler only for specified passes (comma separated list)"),
cl::value_desc("pass-name"), cl::ZeroOrMore, cl::location(RunPassOpt));
static StringRef ToolName;
typedef std::tuple<uint64_t, StringRef, uint8_t> SectionSymbolInfo;
typedef std::vector<SectionSymbolInfo> SectionSymbolsTy;
namespace {
typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate;
class SectionFilterIterator {
public:
SectionFilterIterator(FilterPredicate P,
llvm::object::section_iterator const &I,
llvm::object::section_iterator const &E)
: Predicate(std::move(P)), Iterator(I), End(E) {
ScanPredicate();
}
const llvm::object::SectionRef &operator*() const { return *Iterator; }
SectionFilterIterator &operator++() {
++Iterator;
ScanPredicate();
return *this;
}
bool operator!=(SectionFilterIterator const &Other) const {
return Iterator != Other.Iterator;
}
private:
void ScanPredicate() {
while (Iterator != End && !Predicate(*Iterator)) {
++Iterator;
}
}
FilterPredicate Predicate;
llvm::object::section_iterator Iterator;
llvm::object::section_iterator End;
};
class SectionFilter {
public:
SectionFilter(FilterPredicate P, llvm::object::ObjectFile const &O)
: Predicate(std::move(P)), Object(O) {}
SectionFilterIterator begin() {
return SectionFilterIterator(Predicate, Object.section_begin(),
Object.section_end());
}
SectionFilterIterator end() {
return SectionFilterIterator(Predicate, Object.section_end(),
Object.section_end());
}
private:
FilterPredicate Predicate;
llvm::object::ObjectFile const &Object;
};
SectionFilter ToolSectionFilter(llvm::object::ObjectFile const &O) {
return SectionFilter(
[](llvm::object::SectionRef const &S) {
if (FilterSections.empty())
return true;
llvm::StringRef String;
std::error_code error = S.getName(String);
if (error)
return false;
return is_contained(FilterSections, String);
},
O);
}
} // namespace
void llvm::error(std::error_code EC) {
if (!EC)
return;
errs() << ToolName << ": error reading file: " << EC.message() << ".\n";
errs().flush();
exit(1);
}
LLVM_ATTRIBUTE_NORETURN void llvm::error(Twine Message) {
errs() << ToolName << ": " << Message << ".\n";
errs().flush();
exit(1);
}
LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef File, Twine Message) {
errs() << ToolName << ": '" << File << "': " << Message << ".\n";
exit(1);
}
LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef File,
std::error_code EC) {
assert(EC);
errs() << ToolName << ": '" << File << "': " << EC.message() << ".\n";
exit(1);
}
LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef File, llvm::Error E) {
assert(E);
std::string Buf;
raw_string_ostream OS(Buf);
logAllUnhandledErrors(std::move(E), OS, "");
OS.flush();
errs() << ToolName << ": '" << File << "': " << Buf;
exit(1);
}
LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef ArchiveName,
StringRef FileName,
llvm::Error E,
StringRef ArchitectureName) {
assert(E);
errs() << ToolName << ": ";
if (ArchiveName != "")
errs() << ArchiveName << "(" << FileName << ")";
else
errs() << "'" << FileName << "'";
if (!ArchitectureName.empty())
errs() << " (for architecture " << ArchitectureName << ")";
std::string Buf;
raw_string_ostream OS(Buf);
logAllUnhandledErrors(std::move(E), OS, "");
OS.flush();
errs() << ": " << Buf;
exit(1);
}
LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef ArchiveName,
const object::Archive::Child &C,
llvm::Error E,
StringRef ArchitectureName) {
Expected<StringRef> NameOrErr = C.getName();
// TODO: if we have a error getting the name then it would be nice to print
// the index of which archive member this is and or its offset in the
// archive instead of "???" as the name.
if (!NameOrErr) {
consumeError(NameOrErr.takeError());
llvm::report_error(ArchiveName, "???", std::move(E), ArchitectureName);
} else
llvm::report_error(ArchiveName, NameOrErr.get(), std::move(E),
ArchitectureName);
}
static const Target *getTarget(const ObjectFile *Obj = nullptr) {
// Figure out the target triple.
llvm::Triple TheTriple("unknown-unknown-unknown");
if (TripleName.empty()) {
if (Obj) {
auto Arch = Obj->getArch();
TheTriple.setArch(Triple::ArchType(Arch));
// For ARM targets, try to use the build attributes to build determine
// the build target. Target features are also added, but later during
// disassembly.
if (Arch == Triple::arm || Arch == Triple::armeb) {
Obj->setARMSubArch(TheTriple);
}
// TheTriple defaults to ELF, and COFF doesn't have an environment:
// the best we can do here is indicate that it is mach-o.
if (Obj->isMachO())
TheTriple.setObjectFormat(Triple::MachO);
if (Obj->isCOFF()) {
const auto COFFObj = dyn_cast<COFFObjectFile>(Obj);
if (COFFObj->getArch() == Triple::thumb)
TheTriple.setTriple("thumbv7-windows");
}
}
} else {
TheTriple.setTriple(Triple::normalize(TripleName));
// Use the triple, but also try to combine with ARM build attributes.
if (Obj) {
auto Arch = Obj->getArch();
if (Arch == Triple::arm || Arch == Triple::armeb) {
Obj->setARMSubArch(TheTriple);
}
}
}
// Get the target specific parser.
std::string Error;
const Target *TheTarget =
TargetRegistry::lookupTarget(ArchName, TheTriple, Error);
if (!TheTarget) {
if (Obj)
report_error(Obj->getFileName(), "can't find target: " + Error);
else
error("can't find target: " + Error);
}
// Update the triple name and return the found target.
TripleName = TheTriple.getTriple();
return TheTarget;
}
static std::unique_ptr<ToolOutputFile> GetOutputStream(const char *TargetName,
Triple::OSType OS,
const char *ProgName) {
// If we don't yet have an output filename, make one.
if (OutputFilename.empty()) {
// If InputFilename ends in .o, remove it.
StringRef IFN = InputFilenames[0];
if (IFN.endswith(".o"))
OutputFilename = IFN.drop_back(2);
else if (IFN.endswith(".so"))
OutputFilename = IFN.drop_back(3);
else
OutputFilename = IFN;
switch (OutputFormat) {
case TargetMachine::CGFT_AssemblyFile:
OutputFilename += "-dis.ll";
break;
// Just uses enum CGFT_ObjectFile represent llvm bitcode file type
// provisionally.
case TargetMachine::CGFT_ObjectFile:
OutputFilename += "-dis.bc";
break;
case TargetMachine::CGFT_Null:
OutputFilename += ".null";
break;
}
}
// Decide if we need "binary" output.
bool Binary = false;
switch (OutputFormat) {
case TargetMachine::CGFT_AssemblyFile:
break;
case TargetMachine::CGFT_ObjectFile:
case TargetMachine::CGFT_Null:
Binary = true;
break;
}
// Open the file.
std::error_code EC;
sys::fs::OpenFlags OpenFlags = sys::fs::F_None;
if (!Binary)
OpenFlags |= sys::fs::F_Text;
auto FDOut = llvm::make_unique<ToolOutputFile>(OutputFilename, EC, OpenFlags);
if (EC) {
errs() << EC.message() << '\n';
return nullptr;
}
return FDOut;
}
static bool addPass(PassManagerBase &PM, StringRef toolname, StringRef PassName,
TargetPassConfig &TPC) {
if (PassName == "none")
return false;
const PassRegistry *PR = PassRegistry::getPassRegistry();
const PassInfo *PI = PR->getPassInfo(PassName);
if (!PI) {
errs() << toolname << ": run-pass " << PassName << " is not registered.\n";
return true;
}
Pass *P;
if (PI->getNormalCtor())
P = PI->getNormalCtor()();
else {
errs() << toolname << ": cannot create pass: " << PI->getPassName() << "\n";
return true;
}
std::string Banner = std::string("After ") + std::string(P->getPassName());
PM.add(P);
TPC.printAndVerify(Banner);
return false;
}
bool llvm::RelocAddressLess(RelocationRef a, RelocationRef b) {
return a.getOffset() < b.getOffset();
}
namespace {
class SourcePrinter {
protected:
DILineInfo OldLineInfo;
const ObjectFile *Obj;
std::unique_ptr<symbolize::LLVMSymbolizer> Symbolizer;
// File name to file contents of source
std::unordered_map<std::string, std::unique_ptr<MemoryBuffer>> SourceCache;
// Mark the line endings of the cached source
std::unordered_map<std::string, std::vector<StringRef>> LineCache;
private:
bool cacheSource(std::string File);
public:
virtual ~SourcePrinter() {}
SourcePrinter() : Obj(nullptr), Symbolizer(nullptr) {}
SourcePrinter(const ObjectFile *Obj, StringRef DefaultArch) : Obj(Obj) {
symbolize::LLVMSymbolizer::Options SymbolizerOpts(
DILineInfoSpecifier::FunctionNameKind::None, true, false, false,
DefaultArch);
Symbolizer.reset(new symbolize::LLVMSymbolizer(SymbolizerOpts));
}
virtual void printSourceLine(raw_ostream &OS, uint64_t Address,
StringRef Delimiter = "; ");
};
bool SourcePrinter::cacheSource(std::string File) {
auto BufferOrError = MemoryBuffer::getFile(File);
if (!BufferOrError)
return false;
// Chomp the file to get lines
size_t BufferSize = (*BufferOrError)->getBufferSize();
const char *BufferStart = (*BufferOrError)->getBufferStart();
for (const char *Start = BufferStart, *End = BufferStart;
End < BufferStart + BufferSize; End++)
if (*End == '\n' || End == BufferStart + BufferSize - 1 ||
(*End == '\r' && *(End + 1) == '\n')) {
LineCache[File].push_back(StringRef(Start, End - Start));
if (*End == '\r')
End++;
Start = End + 1;
}
SourceCache[File] = std::move(*BufferOrError);
return true;
}
void SourcePrinter::printSourceLine(raw_ostream &OS, uint64_t Address,
StringRef Delimiter) {
if (!Symbolizer)
return;
DILineInfo LineInfo = DILineInfo();
auto ExpectecLineInfo =
Symbolizer->symbolizeCode(Obj->getFileName(), Address);
if (!ExpectecLineInfo)
consumeError(ExpectecLineInfo.takeError());
else
LineInfo = *ExpectecLineInfo;
if ((LineInfo.FileName == "<invalid>") || OldLineInfo.Line == LineInfo.Line ||
LineInfo.Line == 0)
return;
if (PrintLines)
OS << Delimiter << LineInfo.FileName << ":" << LineInfo.Line << "\n";
if (PrintSource) {
if (SourceCache.find(LineInfo.FileName) == SourceCache.end())
if (!cacheSource(LineInfo.FileName))
return;
auto FileBuffer = SourceCache.find(LineInfo.FileName);
if (FileBuffer != SourceCache.end()) {
auto LineBuffer = LineCache.find(LineInfo.FileName);
if (LineBuffer != LineCache.end()) {
if (LineInfo.Line > LineBuffer->second.size())
return;
// Vector begins at 0, line numbers are non-zero
OS << Delimiter << LineBuffer->second[LineInfo.Line - 1].ltrim()
<< "\n";
}
}
}
OldLineInfo = LineInfo;
}
static bool isArmElf(const ObjectFile *Obj) {
return (Obj->isELF() &&
(Obj->getArch() == Triple::aarch64 ||
Obj->getArch() == Triple::aarch64_be ||
Obj->getArch() == Triple::arm || Obj->getArch() == Triple::armeb ||
Obj->getArch() == Triple::thumb ||
Obj->getArch() == Triple::thumbeb));
}
class PrettyPrinter {
public:
virtual ~PrettyPrinter() {}
virtual void printInst(MCInstPrinter &IP, const MCInst *MI,
ArrayRef<uint8_t> Bytes, uint64_t Address,
raw_ostream &OS, StringRef Annot,
MCSubtargetInfo const &STI, SourcePrinter *SP) {
if (SP && (PrintSource || PrintLines))
SP->printSourceLine(OS, Address);
if (!NoLeadingAddr)
OS << format("%8" PRIx64 ":", Address);
if (!NoShowRawInsn) {
OS << "\t";
dumpBytes(Bytes, OS);
}
if (MI)
IP.printInst(MI, OS, "", STI);
else
OS << " <unknown>";
}
};
PrettyPrinter PrettyPrinterInst;
class HexagonPrettyPrinter : public PrettyPrinter {
public:
void printLead(ArrayRef<uint8_t> Bytes, uint64_t Address, raw_ostream &OS) {
uint32_t opcode =
(Bytes[3] << 24) | (Bytes[2] << 16) | (Bytes[1] << 8) | Bytes[0];
if (!NoLeadingAddr)
OS << format("%8" PRIx64 ":", Address);
if (!NoShowRawInsn) {
OS << "\t";
dumpBytes(Bytes.slice(0, 4), OS);
OS << format("%08" PRIx32, opcode);
}
}
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
uint64_t Address, raw_ostream &OS, StringRef Annot,
MCSubtargetInfo const &STI, SourcePrinter *SP) override {
if (SP && (PrintSource || PrintLines))
SP->printSourceLine(OS, Address, "");
if (!MI) {
printLead(Bytes, Address, OS);
OS << " <unknown>";
return;
}
std::string Buffer;
{
raw_string_ostream TempStream(Buffer);
IP.printInst(MI, TempStream, "", STI);
}
StringRef Contents(Buffer);
// Split off bundle attributes
auto PacketBundle = Contents.rsplit('\n');
// Split off first instruction from the rest
auto HeadTail = PacketBundle.first.split('\n');
auto Preamble = " { ";
auto Separator = "";
while (!HeadTail.first.empty()) {
OS << Separator;
Separator = "\n";
if (SP && (PrintSource || PrintLines))
SP->printSourceLine(OS, Address, "");
printLead(Bytes, Address, OS);
OS << Preamble;
Preamble = " ";
StringRef Inst;
auto Duplex = HeadTail.first.split('\v');
if (!Duplex.second.empty()) {
OS << Duplex.first;
OS << "; ";
Inst = Duplex.second;
} else
Inst = HeadTail.first;
OS << Inst;
Bytes = Bytes.slice(4);
Address += 4;
HeadTail = HeadTail.second.split('\n');
}
OS << " } " << PacketBundle.second;
}
};
HexagonPrettyPrinter HexagonPrettyPrinterInst;
class AMDGCNPrettyPrinter : public PrettyPrinter {
public:
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
uint64_t Address, raw_ostream &OS, StringRef Annot,
MCSubtargetInfo const &STI, SourcePrinter *SP) override {
if (SP && (PrintSource || PrintLines))
SP->printSourceLine(OS, Address);
if (!MI) {
OS << " <unknown>";
return;
}
SmallString<40> InstStr;
raw_svector_ostream IS(InstStr);
IP.printInst(MI, IS, "", STI);
OS << left_justify(IS.str(), 60) << format("// %012" PRIX64 ": ", Address);
typedef support::ulittle32_t U32;
for (auto D : makeArrayRef(reinterpret_cast<const U32 *>(Bytes.data()),
Bytes.size() / sizeof(U32)))
// D should be explicitly casted to uint32_t here as it is passed
// by format to snprintf as vararg.
OS << format("%08" PRIX32 " ", static_cast<uint32_t>(D));
if (!Annot.empty())
OS << "// " << Annot;
}
};
AMDGCNPrettyPrinter AMDGCNPrettyPrinterInst;
class BPFPrettyPrinter : public PrettyPrinter {
public:
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
uint64_t Address, raw_ostream &OS, StringRef Annot,
MCSubtargetInfo const &STI, SourcePrinter *SP) override {
if (SP && (PrintSource || PrintLines))
SP->printSourceLine(OS, Address);
if (!NoLeadingAddr)
OS << format("%8" PRId64 ":", Address / 8);
if (!NoShowRawInsn) {
OS << "\t";
dumpBytes(Bytes, OS);
}
if (MI)
IP.printInst(MI, OS, "", STI);
else
OS << " <unknown>";
}
};
BPFPrettyPrinter BPFPrettyPrinterInst;
PrettyPrinter &selectPrettyPrinter(Triple const &Triple) {
switch (Triple.getArch()) {
default:
return PrettyPrinterInst;
case Triple::hexagon:
return HexagonPrettyPrinterInst;
case Triple::amdgcn:
return AMDGCNPrettyPrinterInst;
case Triple::bpfel:
case Triple::bpfeb:
return BPFPrettyPrinterInst;
}
}
} // namespace
template <class ELFT>
static std::error_code getRelocationValueString(const ELFObjectFile<ELFT> *Obj,
const RelocationRef &RelRef,
SmallVectorImpl<char> &Result) {
DataRefImpl Rel = RelRef.getRawDataRefImpl();
typedef typename ELFObjectFile<ELFT>::Elf_Sym Elf_Sym;
typedef typename ELFObjectFile<ELFT>::Elf_Shdr Elf_Shdr;
typedef typename ELFObjectFile<ELFT>::Elf_Rela Elf_Rela;
const ELFFile<ELFT> &EF = *Obj->getELFFile();
auto SecOrErr = EF.getSection(Rel.d.a);
if (!SecOrErr)
return errorToErrorCode(SecOrErr.takeError());
const Elf_Shdr *Sec = *SecOrErr;
auto SymTabOrErr = EF.getSection(Sec->sh_link);
if (!SymTabOrErr)
return errorToErrorCode(SymTabOrErr.takeError());
const Elf_Shdr *SymTab = *SymTabOrErr;
assert(SymTab->sh_type == ELF::SHT_SYMTAB ||
SymTab->sh_type == ELF::SHT_DYNSYM);
auto StrTabSec = EF.getSection(SymTab->sh_link);
if (!StrTabSec)
return errorToErrorCode(StrTabSec.takeError());
auto StrTabOrErr = EF.getStringTable(*StrTabSec);
if (!StrTabOrErr)
return errorToErrorCode(StrTabOrErr.takeError());
StringRef StrTab = *StrTabOrErr;
uint8_t type = RelRef.getType();
StringRef res;
int64_t addend = 0;
switch (Sec->sh_type) {
default:
return object_error::parse_failed;
case ELF::SHT_REL: {
// TODO: Read implicit addend from section data.
break;
}
case ELF::SHT_RELA: {
const Elf_Rela *ERela = Obj->getRela(Rel);
addend = ERela->r_addend;
break;
}
}
symbol_iterator SI = RelRef.getSymbol();
const Elf_Sym *symb = Obj->getSymbol(SI->getRawDataRefImpl());
StringRef Target;
if (symb->getType() == ELF::STT_SECTION) {
Expected<section_iterator> SymSI = SI->getSection();
if (!SymSI)
return errorToErrorCode(SymSI.takeError());
const Elf_Shdr *SymSec = Obj->getSection((*SymSI)->getRawDataRefImpl());
auto SecName = EF.getSectionName(SymSec);
if (!SecName)
return errorToErrorCode(SecName.takeError());
Target = *SecName;
} else {
Expected<StringRef> SymName = symb->getName(StrTab);
if (!SymName)
return errorToErrorCode(SymName.takeError());
Target = *SymName;
}
switch (EF.getHeader()->e_machine) {
case ELF::EM_X86_64:
switch (type) {
case ELF::R_X86_64_PC8:
case ELF::R_X86_64_PC16:
case ELF::R_X86_64_PC32: {
std::string fmtbuf;
raw_string_ostream fmt(fmtbuf);
fmt << Target << (addend < 0 ? "" : "+") << addend << "-P";
fmt.flush();
Result.append(fmtbuf.begin(), fmtbuf.end());
} break;
case ELF::R_X86_64_8:
case ELF::R_X86_64_16:
case ELF::R_X86_64_32:
case ELF::R_X86_64_32S:
case ELF::R_X86_64_64: {
std::string fmtbuf;
raw_string_ostream fmt(fmtbuf);
fmt << Target << (addend < 0 ? "" : "+") << addend;
fmt.flush();
Result.append(fmtbuf.begin(), fmtbuf.end());
} break;
default:
res = "Unknown";
}
break;
case ELF::EM_LANAI:
case ELF::EM_AVR:
case ELF::EM_AARCH64: {
std::string fmtbuf;
raw_string_ostream fmt(fmtbuf);
fmt << Target;
if (addend != 0)
fmt << (addend < 0 ? "" : "+") << addend;
fmt.flush();
Result.append(fmtbuf.begin(), fmtbuf.end());
break;
}
case ELF::EM_386:
case ELF::EM_IAMCU:
case ELF::EM_ARM:
case ELF::EM_HEXAGON:
case ELF::EM_MIPS:
case ELF::EM_BPF:
case ELF::EM_RISCV:
res = Target;
break;
default:
res = "Unknown";
}
if (Result.empty())
Result.append(res.begin(), res.end());
return std::error_code();
}
static uint8_t getElfSymbolType(const ObjectFile *Obj, const SymbolRef &Sym) {
assert(Obj->isELF());
if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(Obj))
return Elf32LEObj->getSymbol(Sym.getRawDataRefImpl())->getType();
if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(Obj))
return Elf64LEObj->getSymbol(Sym.getRawDataRefImpl())->getType();
if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(Obj))
return Elf32BEObj->getSymbol(Sym.getRawDataRefImpl())->getType();
if (auto *Elf64BEObj = cast<ELF64BEObjectFile>(Obj))
return Elf64BEObj->getSymbol(Sym.getRawDataRefImpl())->getType();
llvm_unreachable("Unsupported binary format");
// Keep the code analyzer happy
return ELF::STT_NOTYPE;
}
template <class ELFT>
static void
addDynamicElfSymbols(const ELFObjectFile<ELFT> *Obj,
std::map<SectionRef, SectionSymbolsTy> &AllSymbols) {
for (auto Symbol : Obj->getDynamicSymbolIterators()) {
uint8_t SymbolType = Symbol.getELFType();
if (SymbolType != ELF::STT_FUNC || Symbol.getSize() == 0)
continue;
Expected<uint64_t> AddressOrErr = Symbol.getAddress();
if (!AddressOrErr)
report_error(Obj->getFileName(), AddressOrErr.takeError());
uint64_t Address = *AddressOrErr;
Expected<StringRef> Name = Symbol.getName();
if (!Name)
report_error(Obj->getFileName(), Name.takeError());
if (Name->empty())
continue;
Expected<section_iterator> SectionOrErr = Symbol.getSection();
if (!SectionOrErr)
report_error(Obj->getFileName(), SectionOrErr.takeError());
section_iterator SecI = *SectionOrErr;
if (SecI == Obj->section_end())
continue;
AllSymbols[*SecI].emplace_back(Address, *Name, SymbolType);
}
}
static void
addDynamicElfSymbols(const ObjectFile *Obj,
std::map<SectionRef, SectionSymbolsTy> &AllSymbols) {
assert(Obj->isELF());
if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(Obj))
addDynamicElfSymbols(Elf32LEObj, AllSymbols);
else if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(Obj))
addDynamicElfSymbols(Elf64LEObj, AllSymbols);
else if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(Obj))
addDynamicElfSymbols(Elf32BEObj, AllSymbols);
else if (auto *Elf64BEObj = cast<ELF64BEObjectFile>(Obj))
addDynamicElfSymbols(Elf64BEObj, AllSymbols);
else
llvm_unreachable("Unsupported binary format");
}
/*
A list of symbol entries corresponding to CRT functions added by
the linker while creating an ELF executable. It is not necessary to
disassemble and translate these functions.
*/
static std::set<StringRef> ELFCRTSymbols = {
"deregister_tm_clones",
"__do_global_dtors_aux",
"__do_global_dtors_aux_fini_array_entry",
"_fini",
"frame_dummy",
"__frame_dummy_init_array_entry",
"_init",
"__init_array_end",
"__init_array_start",
"__libc_csu_fini",
"__libc_csu_init",
"register_tm_clones",
"_start"};
/*
A list of symbol entries corresponding to CRT functions added by
the linker while creating an MachO executable. It is not necessary
to disassemble and translate these functions.
*/
static std::set<StringRef> MachOCRTSymbols = {"__mh_execute_header",
"dyld_stub_binder", "__text",
"__stubs", "__stub_helper"};
/*
A list of sections whose contents are to be disassembled as code
*/
static std::set<StringRef> ELFSectionsToDisassemble = {".text"};
static std::set<StringRef> MachOSectionsToDisassemble = {};
/* TODO : If it is a C++ binary object symbol, look at the
signature of the symbol to deduce the return value and return
type. If the symbol does not include the function signature,
just create a function that takes no arguments */
/* A non vararg function type with no arguments */
/* TODO: Figure out the symbol linkage type from the symbol
table. For now assuming global linkage
*/
static bool isAFunctionSymbol(const ObjectFile *Obj,
SectionSymbolInfo &Symbol) {
if (Obj->isELF()) {
return (std::get<2>(Symbol) == ELF::STT_FUNC);
}
if (Obj->isMachO()) {
// If Symbol is not in the MachOCRTSymbol list return true indicating that
// this is a symbol of a function we are interested in disassembling and
// raising.
return (MachOCRTSymbols.find(std::get<1>(Symbol)) == MachOCRTSymbols.end());
}
return false;
}
static bool disasmSection(const ObjectFile *Obj, StringRef &sectionName) {
if (Obj->isELF()) {
return (ELFSectionsToDisassemble.find(sectionName) !=
ELFSectionsToDisassemble.end());
}
if (Obj->isMachO()) {
// Already picking up the text section
return true;
}
return false;
}
static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
if (StartAddress > StopAddress)
error("Start address should be less than stop address");
const Target *TheTarget = getTarget(Obj);
// Package up features to be passed to target/subtarget
SubtargetFeatures Features = Obj->getFeatures();
if (MAttrs.size()) {
for (unsigned i = 0; i != MAttrs.size(); ++i)
Features.AddFeature(MAttrs[i]);
}
std::unique_ptr<const MCRegisterInfo> MRI(
TheTarget->createMCRegInfo(TripleName));
if (!MRI)
report_error(Obj->getFileName(),
"no register info for target " + TripleName);
// Set up disassembler.
std::unique_ptr<const MCAsmInfo> AsmInfo(
TheTarget->createMCAsmInfo(*MRI, TripleName));
if (!AsmInfo)
report_error(Obj->getFileName(),
"no assembly info for target " + TripleName);
std::unique_ptr<const MCSubtargetInfo> STI(
TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString()));
if (!STI)
report_error(Obj->getFileName(),
"no subtarget info for target " + TripleName);
std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
if (!MII)
report_error(Obj->getFileName(),
"no instruction info for target " + TripleName);
MCObjectFileInfo MOFI;
MCContext Ctx(AsmInfo.get(), MRI.get(), &MOFI);
// FIXME: for now initialize MCObjectFileInfo with default values
MOFI.InitMCObjectFileInfo(Triple(TripleName), false, Ctx);
std::unique_ptr<MCDisassembler> DisAsm(
TheTarget->createMCDisassembler(*STI, Ctx));
if (!DisAsm)
report_error(Obj->getFileName(),
"no disassembler for target " + TripleName);
std::unique_ptr<const MCInstrAnalysis> MIA(
TheTarget->createMCInstrAnalysis(MII.get()));
int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
Triple(TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI));
if (!IP)
report_error(Obj->getFileName(),
"no instruction printer for target " + TripleName);
IP->setPrintImmHex(PrintImmHex);
PrettyPrinter &PIP = selectPrettyPrinter(Triple(TripleName));
SourcePrinter SP(Obj, TheTarget->getName());
LLVMContext llvmCtx;
std::unique_ptr<TargetMachine> Target(
TheTarget->createTargetMachine(TripleName, MCPU, Features.getString(),
TargetOptions(), /* RelocModel */ None));
assert(Target && "Could not allocate target machine!");
// LLVMTargetMachine &llvmTgtMach = static_cast<LLVMTargetMachine&>(*Target);
MachineModuleInfo *machineModuleInfo = new MachineModuleInfo(Target.get());
/* New Module instance with file name */
Module module(Obj->getFileName(), llvmCtx);
/* Set datalayout of the module to be the same as LLVMTargetMachine */
module.setDataLayout(Target->createDataLayout());
machineModuleInfo->doInitialization(module);
ModuleRaiser *moduleRaiser =
new ModuleRaiser(module, Target.get(), machineModuleInfo, MIA.get(),
MII.get(), Obj, DisAsm.get());
if (!moduleRaiser->isSupportedArch())
return;
// Create a mapping, RelocSecs = SectionRelocMap[S], where sections
// in RelocSecs contain the relocations for section S.
std::error_code EC;
std::map<SectionRef, SmallVector<SectionRef, 1>> SectionRelocMap;
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
section_iterator Sec2 = Section.getRelocatedSection();
if (Sec2 != Obj->section_end())
SectionRelocMap[*Sec2].push_back(Section);
}
// Create a mapping from virtual address to symbol name. This is used to
// pretty print the symbols while disassembling.
std::map<SectionRef, SectionSymbolsTy> AllSymbols;
for (const SymbolRef &Symbol : Obj->symbols()) {
Expected<uint64_t> AddressOrErr = Symbol.getAddress();
if (!AddressOrErr)
report_error(Obj->getFileName(), AddressOrErr.takeError());
uint64_t Address = *AddressOrErr;
Expected<StringRef> Name = Symbol.getName();
if (!Name)
report_error(Obj->getFileName(), Name.takeError());
if (Name->empty())
continue;
Expected<section_iterator> SectionOrErr = Symbol.getSection();
if (!SectionOrErr)
report_error(Obj->getFileName(), SectionOrErr.takeError());
section_iterator SecI = *SectionOrErr;
if (SecI == Obj->section_end())
continue;
uint8_t SymbolType = ELF::STT_NOTYPE;
if (Obj->isELF())
SymbolType = getElfSymbolType(Obj, Symbol);
AllSymbols[*SecI].emplace_back(Address, *Name, SymbolType);
}
if (AllSymbols.empty() && Obj->isELF())
addDynamicElfSymbols(Obj, AllSymbols);
// Create a mapping from virtual address to section.
std::vector<std::pair<uint64_t, SectionRef>> SectionAddresses;
for (SectionRef Sec : Obj->sections())
SectionAddresses.emplace_back(Sec.getAddress(), Sec);
array_pod_sort(SectionAddresses.begin(), SectionAddresses.end());
// Linked executables (.exe and .dll files) typically don't include a real
// symbol table but they might contain an export table.
if (const auto *COFFObj = dyn_cast<COFFObjectFile>(Obj)) {
for (const auto &ExportEntry : COFFObj->export_directories()) {
StringRef Name;
error(ExportEntry.getSymbolName(Name));
if (Name.empty())
continue;
uint32_t RVA;
error(ExportEntry.getExportRVA(RVA));
uint64_t VA = COFFObj->getImageBase() + RVA;
auto Sec = std::upper_bound(
SectionAddresses.begin(), SectionAddresses.end(), VA,
[](uint64_t LHS, const std::pair<uint64_t, SectionRef> &RHS) {
return LHS < RHS.first;
});
if (Sec != SectionAddresses.begin())
--Sec;
else
Sec = SectionAddresses.end();
if (Sec != SectionAddresses.end())
AllSymbols[Sec->second].emplace_back(VA, Name, ELF::STT_NOTYPE);
}
}
// Sort all the symbols, this allows us to use a simple binary search to find
// a symbol near an address.
for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols)
array_pod_sort(SecSyms.second.begin(), SecSyms.second.end());
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
if ((!Section.isText() || Section.isVirtual()))
continue;
StringRef SectionName;
Section.getName(SectionName);
if (SectionName.compare(".text") != 0) {
continue;
}
uint64_t SectionAddr = Section.getAddress();
uint64_t SectSize = Section.getSize();
if (!SectSize)
continue;
// Get the list of all the symbols in this section.
SectionSymbolsTy &Symbols = AllSymbols[Section];
std::vector<uint64_t> DataMappingSymsAddr;
std::vector<uint64_t> TextMappingSymsAddr;
if (isArmElf(Obj)) {
for (const auto &Symb : Symbols) {
uint64_t Address = std::get<0>(Symb);
StringRef Name = std::get<1>(Symb);
if (Name.startswith("$d"))
DataMappingSymsAddr.push_back(Address - SectionAddr);
if (Name.startswith("$x"))
TextMappingSymsAddr.push_back(Address - SectionAddr);
if (Name.startswith("$a"))
TextMappingSymsAddr.push_back(Address - SectionAddr);
if (Name.startswith("$t"))
TextMappingSymsAddr.push_back(Address - SectionAddr);
}
}
std::sort(DataMappingSymsAddr.begin(), DataMappingSymsAddr.end());
std::sort(TextMappingSymsAddr.begin(), TextMappingSymsAddr.end());
if (Obj->isELF() && Obj->getArch() == Triple::amdgcn) {
// AMDGPU disassembler uses symbolizer for printing labels
std::unique_ptr<MCRelocationInfo> RelInfo(
TheTarget->createMCRelocationInfo(TripleName, Ctx));
if (RelInfo) {
std::unique_ptr<MCSymbolizer> Symbolizer(TheTarget->createMCSymbolizer(
TripleName, nullptr, nullptr, &Symbols, &Ctx, std::move(RelInfo)));
DisAsm->setSymbolizer(std::move(Symbolizer));
}
}
// Make a list of all the relocations for this section.
std::vector<RelocationRef> Rels;
if (InlineRelocs) {
for (const SectionRef &RelocSec : SectionRelocMap[Section]) {
for (const RelocationRef &Reloc : RelocSec.relocations()) {
Rels.push_back(Reloc);
}
}
}
// Sort relocations by address.
std::sort(Rels.begin(), Rels.end(), RelocAddressLess);
StringRef SegmentName = "";
if (const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj)) {
DataRefImpl DR = Section.getRawDataRefImpl();
SegmentName = MachO->getSectionFinalSegmentName(DR);
}
StringRef name;
error(Section.getName(name));
if (!disasmSection(Obj, name)) {
continue;
}
bool PrintAll =
(cl::getRegisteredOptions()["print-after-all"]->getNumOccurrences() >
0);
if (PrintAll) {
if ((SectionAddr <= StopAddress) &&
(SectionAddr + SectSize) >= StartAddress) {
outs() << "Disassembling section ";
if (!SegmentName.empty())
outs() << SegmentName << ",";
outs() << name << "\n";
}
}
// If the section has no symbol at the start, just insert a dummy one.
if (Symbols.empty() || std::get<0>(Symbols[0]) != 0) {
Symbols.insert(
Symbols.begin(),
std::make_tuple(SectionAddr, name,
Section.isText() ? ELF::STT_FUNC : ELF::STT_OBJECT));
}
SmallString<40> Comments;
raw_svector_ostream CommentStream(Comments);
StringRef BytesStr;
error(Section.getContents(BytesStr));
ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()),
BytesStr.size());
uint64_t Size;
uint64_t Index;
// Build a set of function symbol names to operate on,
// if specified on the command-line.
std::set<StringRef> filterFunctionSet;
for (unsigned i = 0; i < FilterFunctions.size(); ++i) {
filterFunctionSet.insert(FilterFunctions[i]);
}
// Build a map of relocations (if they exist in the binary) of text
// section whose instructions are being raised.
moduleRaiser->collectTextSectionRelocs(Section);
// Set used to record all branch targets of a function.
std::set<uint64_t> branchTargetSet;
MachineFunctionRaiser *curMFRaiser = nullptr;
// Disassemble symbol by symbol.
for (unsigned si = 0, se = Symbols.size(); si != se; ++si) {
uint64_t Start = std::get<0>(Symbols[si]) - SectionAddr;
// The end is either the section end or the beginning of the next
// symbol.
uint64_t End = (si == se - 1)
? SectSize
: std::get<0>(Symbols[si + 1]) - SectionAddr;
// Don't try to disassemble beyond the end of section contents.
if (End > SectSize)
End = SectSize;
// If this symbol has the same address as the next symbol, then skip it.
if (Start >= End)
continue;
// Check if we need to skip symbol
// Skip if the symbol's data is not between StartAddress and StopAddress
if (End + SectionAddr < StartAddress ||
Start + SectionAddr > StopAddress) {
continue;
}
// Stop disassembly at the stop address specified
if (End + SectionAddr > StopAddress)
End = StopAddress - SectionAddr;
if (Obj->isELF() && Obj->getArch() == Triple::amdgcn) {
// make size 4 bytes folded
End = Start + ((End - Start) & ~0x3ull);
if (std::get<2>(Symbols[si]) == ELF::STT_AMDGPU_HSA_KERNEL) {
// skip amd_kernel_code_t at the begining of kernel symbol (256 bytes)
Start += 256;
}
if (si == se - 1 ||
std::get<2>(Symbols[si + 1]) == ELF::STT_AMDGPU_HSA_KERNEL) {
// cut trailing zeroes at the end of kernel
// cut up to 256 bytes
const uint64_t EndAlign = 256;
const auto Limit = End - (std::min)(EndAlign, End - Start);
while (End > Limit && *reinterpret_cast<const support::ulittle32_t *>(
&Bytes[End - 4]) == 0)
End -= 4;
}
}
#ifndef NDEBUG
raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls();
#else
raw_ostream &DebugOut = nulls();
#endif
if (isAFunctionSymbol(Obj, Symbols[si])) {
if (!((FilterFunctions.getNumOccurrences() == 0) ||
(filterFunctionSet.find(std::get<1>(Symbols[si])) !=
filterFunctionSet.end()))) {
// This symbol is part of the filter symbols specified.
continue;
}
// If Symbol is in the ELFCRTSymbol list return this is a symbol of a
// function we are not interested in disassembling and raising.
if (ELFCRTSymbols.find(std::get<1>(Symbols[si])) !=
ELFCRTSymbols.end()) {
continue;
}
// Note that since LLVM infrastructure was built to be used to build a
// conventional compiler pipeline, MachineFunction is built well after
// Function object was created and populated fully. Hence, creation of
// a Function object is necessary to build MachineFunction.
// However, in a raiser, we are conceptually walking the traditional
// compiler pipeline backwards. So we build MachineFunction from
// the binary before building Function object. Given the dependency,
// build a place holder Function object to allow for building the
// MachineFunction object.
// This Function object is NOT populated when raising MachineFunction
// abstraction of the binary function. Instead, a new Function is
// created using the LLVMContext and name of this Function object.
FunctionType *FTy = FunctionType::get(Type::getVoidTy(llvmCtx), false);
StringRef FunctionName(std::get<1>(Symbols[si]));
// Strip leading underscore if the binary is MachO
if (Obj->isMachO()) {
FunctionName.consume_front("_");
}
Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage,
FunctionName, &module);
// While PassManager is running FunctionPasses, it will check if current
// Function is empty or not. If the Function is empty, it will be
// skipped. So add an empty BasicBlock to Functions at here to guarantee
// the corresponding MachineFunction can be run.
// TODO: This BasicBlock should be removed when add real BasicBlocks.
BasicBlock::Create(Func->getContext(), "Useless", Func);
// New function symbol encountered. Record all targets collected to
// current MachineFunctionRaiser before we start parsing the new
// function bytes.
curMFRaiser = moduleRaiser->getCurrentMachineFunctionRaiser();
for (auto target : branchTargetSet) {
assert(curMFRaiser != nullptr &&
"Encountered unintialized MachineFunction raiser object");
curMFRaiser->getMCInstRaiser()->addTarget(target);
}
// Clear the set used to record all branch targets of this function.
branchTargetSet.clear();
// Create a new MachineFunction raiser
curMFRaiser = moduleRaiser->CreateAndAddMachineFunctionRaiser(
Func, moduleRaiser, Start, End);
// Flag to indicate all instructions of the current function were
// successfully decoded.
// TODO: As of now, we will only raise functions with all instructions
// decoded.
// bool allInstructionsDecoded = true;
if (PrintAll)
outs() << "\nFunction " << std::get<1>(Symbols[si]) << ":\n";
} else {
// Continue using to the most recent MachineFunctionRaiser
// Get current MachineFunctionRaiser
curMFRaiser = moduleRaiser->getCurrentMachineFunctionRaiser();
// assert(curMFRaiser != nullptr && "Current Machine Function Raiser not
// initialized");
if (curMFRaiser == nullptr) {
// At this point in the instruction stream, we do not have a function
// symbol to which the bytes being parsed can be made part of. So skip
// parsing the bytes of this symbol.
continue;
}
// Adjust function end to represent the addition of the content of the
// current symbol. This represents a situation where we have discovered
// bytes (most likely data bytes) that belong to the most recent
// function being parsed.
MCInstRaiser *mcInstRaiser = curMFRaiser->getMCInstRaiser();
if (mcInstRaiser->getFuncEnd() < End) {
assert(mcInstRaiser->adjustFuncEnd(End) &&
"Unable to adjust function end value");
}
}
// Get the associated MCInstRaiser
MCInstRaiser *mcInstRaiser = curMFRaiser->getMCInstRaiser();
// Start new basic block at the symbol.
branchTargetSet.insert(Start);
for (Index = Start; Index < End; Index += Size) {
MCInst Inst;
if (Index + SectionAddr < StartAddress ||
Index + SectionAddr > StopAddress) {
// skip byte by byte till StartAddress is reached
Size = 1;
continue;
}
// AArch64 ELF binaries can interleave data and text in the
// same section. We rely on the markers introduced to
// understand what we need to dump. If the data marker is within a
// function, it is denoted as a word/short etc
if (isArmElf(Obj) && std::get<2>(Symbols[si]) != ELF::STT_OBJECT) {
uint64_t Stride = 0;
auto DAI = std::lower_bound(DataMappingSymsAddr.begin(),
DataMappingSymsAddr.end(), Index);
if (DAI != DataMappingSymsAddr.end() && *DAI == Index) {
// Switch to data.
while (Index < End) {
if (Index + 4 <= End) {
Stride = 4;
uint32_t Data = 0;
if (Obj->isLittleEndian()) {
const auto Word =
reinterpret_cast<const support::ulittle32_t *>(
Bytes.data() + Index);
Data = *Word;
} else {
const auto Word = reinterpret_cast<const support::ubig32_t *>(
Bytes.data() + Index);
Data = *Word;
}
mcInstRaiser->addMCInstOrData(Index, Data);
} else if (Index + 2 <= End) {
Stride = 2;
uint16_t Data = 0;
if (Obj->isLittleEndian()) {
const auto Short =
reinterpret_cast<const support::ulittle16_t *>(
Bytes.data() + Index);
Data = *Short;
} else {
const auto Short =
reinterpret_cast<const support::ubig16_t *>(Bytes.data() +
Index);
Data = *Short;
}
mcInstRaiser->addMCInstOrData(Index, Data);
} else {
Stride = 1;
mcInstRaiser->addMCInstOrData(Index, Bytes.slice(Index, 1)[0]);
}
Index += Stride;
auto TAI = std::lower_bound(TextMappingSymsAddr.begin(),
TextMappingSymsAddr.end(), Index);
if (TAI != TextMappingSymsAddr.end() && *TAI == Index)
break;
}
}
}
// If there is a data symbol inside an ELF text section and we are
// only disassembling text, we are in a situation where we must print
// the data and not disassemble it.
// TODO : Get rid of the following code in the if-block.
if (Obj->isELF() && std::get<2>(Symbols[si]) == ELF::STT_OBJECT &&
Section.isText()) {
// parse data up to 8 bytes at a time
uint8_t AsciiData[9] = {'\0'};
uint8_t Byte;
int NumBytes = 0;
for (Index = Start; Index < End; Index += 1) {
if (((SectionAddr + Index) < StartAddress) ||
((SectionAddr + Index) > StopAddress))
continue;
if (NumBytes == 0) {
outs() << format("%8" PRIx64 ":", SectionAddr + Index);
outs() << "\t";
}
Byte = Bytes.slice(Index)[0];
outs() << format(" %02x", Byte);
AsciiData[NumBytes] = isprint(Byte) ? Byte : '.';
uint8_t IndentOffset = 0;
NumBytes++;
if (Index == End - 1 || NumBytes > 8) {
// Indent the space for less than 8 bytes data.
// 2 spaces for byte and one for space between bytes
IndentOffset = 3 * (8 - NumBytes);
for (int Excess = 8 - NumBytes; Excess < 8; Excess++)
AsciiData[Excess] = '\0';
NumBytes = 8;
}
if (NumBytes == 8) {
AsciiData[8] = '\0';
outs() << std::string(IndentOffset, ' ') << " ";
outs() << reinterpret_cast<char *>(AsciiData);
outs() << '\n';
NumBytes = 0;
}
}
}
if (Index >= End)
break;
// Disassemble a real instruction or a data
bool Disassembled = DisAsm->getInstruction(
Inst, Size, Bytes.slice(Index), SectionAddr + Index, DebugOut,
CommentStream);
if (Size == 0)
Size = 1;
if (!Disassembled) {
errs() << "**** Warning: Failed to decode instruction\n";
PIP.printInst(*IP, Disassembled ? &Inst : nullptr,
Bytes.slice(Index, Size), SectionAddr + Index, outs(),
"", *STI, &SP);
outs() << CommentStream.str();
Comments.clear();
errs() << "\n";
}
// allInstructionsDecoded &= Disassembled;
// Add MCInst to the list if all instructions were decoded
// successfully till now. Else, do not bother adding since no attemt
// will be made to raise this function.
if (Disassembled) {
mcInstRaiser->addMCInstOrData(Index, Inst);
// Find branch target and record it. Call targets are not
// recorded as they are not needed to build per-function CFG.
if (MIA && MIA->isBranch(Inst)) {
uint64_t Target;
if (MIA->evaluateBranch(Inst, Index, Size, Target)) {
// In a relocatable object, the target's section must reside in
// the same section as the call instruction or it is accessed
// through a relocation.
//
// In a non-relocatable object, the target may be in any
// section.
//
// N.B. We don't walk the relocations in the relocatable case
// yet.
if (!Obj->isRelocatableObject()) {
auto SectionAddress = std::upper_bound(
SectionAddresses.begin(), SectionAddresses.end(), Target,
[](uint64_t LHS,
const std::pair<uint64_t, SectionRef> &RHS) {
return LHS < RHS.first;
});
if (SectionAddress != SectionAddresses.begin()) {
--SectionAddress;
}
}
// Add the index Target to target indices set.
branchTargetSet.insert(Target);
}
// Mark the next instruction as a target.
uint64_t fallThruIndex = Index + Size;
branchTargetSet.insert(fallThruIndex);
}
}
}
filterFunctionSet.erase(std::get<1>(Symbols[si]));
}
// Record all targets of the last function parsed
curMFRaiser = moduleRaiser->getCurrentMachineFunctionRaiser();
for (auto target : branchTargetSet)
curMFRaiser->getMCInstRaiser()->addTarget(target);
moduleRaiser->runMachineFunctionPasses();
if (filterFunctionSet.size() > 0) {
errs() << "***** WARNING: The following specified symbol(s) are not "
"found :\n\t";
for (std::set<StringRef>::iterator it = filterFunctionSet.begin();
it != filterFunctionSet.end(); it++) {
errs() << *it << " ";
}
errs() << "\n";
}
}
// Add the pass manager
Triple TheTriple = Triple(TripleName);
// Decide where to send the output.
std::unique_ptr<ToolOutputFile> Out =
GetOutputStream(TheTarget->getName(), TheTriple.getOS(), ToolName.data());
if (!Out)
return;
// Keep the file created.
Out->keep();
raw_pwrite_stream *OS = &Out->os();
legacy::PassManager PM;
LLVMTargetMachine &LLVMTM = static_cast<LLVMTargetMachine &>(*Target);
if (RunPassNames->empty()) {
TargetPassConfig &TPC = *LLVMTM.createPassConfig(PM);
if (TPC.hasLimitedCodeGenPipeline()) {
errs() << ToolName << ": run-pass cannot be used with "
<< TPC.getLimitedCodeGenPipelineReason(" and ") << ".\n";
return;
}
TPC.setDisableVerify(NoVerify);
PM.add(&TPC);
PM.add(machineModuleInfo);
// Add print pass to emit ouptut file.
PM.add(new EmitRaisedOutputPass(*OS, OutputFormat));
TPC.printAndVerify("");
for (const std::string &RunPassName : *RunPassNames) {
if (addPass(PM, ToolName, RunPassName, TPC))
return;
}
TPC.setInitialized();
} else if (Target->addPassesToEmitFile(
PM, *OS, nullptr, /* no dwarf output file stream*/
OutputFormat, NoVerify, machineModuleInfo)) {
outs() << ToolName << "run system pass!\n";
}
cl::PrintOptionValues();
PM.run(module);
}
void llvm::PrintSectionHeaders(const ObjectFile *Obj) {
outs() << "Sections:\n"
"Idx Name Size Address Type\n";
unsigned i = 0;
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
StringRef Name;
error(Section.getName(Name));
uint64_t Address = Section.getAddress();
uint64_t Size = Section.getSize();
bool Text = Section.isText();
bool Data = Section.isData();
bool BSS = Section.isBSS();
std::string Type = (std::string(Text ? "TEXT " : "") +
(Data ? "DATA " : "") + (BSS ? "BSS" : ""));
outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %s\n", i,
Name.str().c_str(), Size, Address, Type.c_str());
++i;
}
}
void llvm::PrintSymbolTable(const ObjectFile *o, StringRef ArchiveName,
StringRef ArchitectureName) {
outs() << "SYMBOL TABLE:\n";
if (const COFFObjectFile *coff = dyn_cast<const COFFObjectFile>(o)) {
printCOFFSymbolTable(coff);
return;
}
for (const SymbolRef &Symbol : o->symbols()) {
Expected<uint64_t> AddressOrError = Symbol.getAddress();
if (!AddressOrError)
report_error(ArchiveName, o->getFileName(), AddressOrError.takeError(),
ArchitectureName);
uint64_t Address = *AddressOrError;
if ((Address < StartAddress) || (Address > StopAddress))
continue;
Expected<SymbolRef::Type> TypeOrError = Symbol.getType();
if (!TypeOrError)
report_error(ArchiveName, o->getFileName(), TypeOrError.takeError(),
ArchitectureName);
SymbolRef::Type Type = *TypeOrError;
uint32_t Flags = Symbol.getFlags();
Expected<section_iterator> SectionOrErr = Symbol.getSection();
if (!SectionOrErr)
report_error(ArchiveName, o->getFileName(), SectionOrErr.takeError(),
ArchitectureName);
section_iterator Section = *SectionOrErr;
StringRef Name;
if (Type == SymbolRef::ST_Debug && Section != o->section_end()) {
Section->getName(Name);
} else {
Expected<StringRef> NameOrErr = Symbol.getName();
if (!NameOrErr)
report_error(ArchiveName, o->getFileName(), NameOrErr.takeError(),
ArchitectureName);
Name = *NameOrErr;
}
bool Global = Flags & SymbolRef::SF_Global;
bool Weak = Flags & SymbolRef::SF_Weak;
bool Absolute = Flags & SymbolRef::SF_Absolute;
bool Common = Flags & SymbolRef::SF_Common;
bool Hidden = Flags & SymbolRef::SF_Hidden;
char GlobLoc = ' ';
if (Type != SymbolRef::ST_Unknown)
GlobLoc = Global ? 'g' : 'l';
char Debug =
(Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File) ? 'd' : ' ';
char FileFunc = ' ';
if (Type == SymbolRef::ST_File)
FileFunc = 'f';
else if (Type == SymbolRef::ST_Function)
FileFunc = 'F';
const char *Fmt = o->getBytesInAddress() > 4 ? "%016" PRIx64 : "%08" PRIx64;
outs() << format(Fmt, Address) << " "
<< GlobLoc // Local -> 'l', Global -> 'g', Neither -> ' '
<< (Weak ? 'w' : ' ') // Weak?
<< ' ' // Constructor. Not supported yet.
<< ' ' // Warning. Not supported yet.
<< ' ' // Indirect reference to another symbol.
<< Debug // Debugging (d) or dynamic (D) symbol.
<< FileFunc // Name of function (F), file (f) or object (O).
<< ' ';
if (Absolute) {
outs() << "*ABS*";
} else if (Common) {
outs() << "*COM*";
} else if (Section == o->section_end()) {
outs() << "*UND*";
} else {
if (const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(o)) {
DataRefImpl DR = Section->getRawDataRefImpl();
StringRef SegmentName = MachO->getSectionFinalSegmentName(DR);
outs() << SegmentName << ",";
}
StringRef SectionName;
error(Section->getName(SectionName));
outs() << SectionName;
}
outs() << '\t';
if (Common || isa<ELFObjectFileBase>(o)) {
uint64_t Val =
Common ? Symbol.getAlignment() : ELFSymbolRef(Symbol).getSize();
outs() << format("\t %08" PRIx64 " ", Val);
}
if (Hidden) {
outs() << ".hidden ";
}
outs() << Name << '\n';
}
}
static void PrintUnwindInfo(const ObjectFile *o) {
outs() << "Unwind info:\n\n";
if (const COFFObjectFile *coff = dyn_cast<COFFObjectFile>(o)) {
printCOFFUnwindInfo(coff);
} else if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
printMachOUnwindInfo(MachO);
else {
// TODO: Extract DWARF dump tool to objdump.
errs() << "This operation is only currently supported "
"for COFF and MachO object files.\n";
return;
}
}
void llvm::printExportsTrie(const ObjectFile *o) {
outs() << "Exports trie:\n";
if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
printMachOExportsTrie(MachO);
else {
errs() << "This operation is only currently supported "
"for Mach-O executable files.\n";
return;
}
}
void llvm::printRebaseTable(ObjectFile *o) {
outs() << "Rebase table:\n";
if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
printMachORebaseTable(MachO);
else {
errs() << "This operation is only currently supported "
"for Mach-O executable files.\n";
return;
}
}
void llvm::printBindTable(ObjectFile *o) {
outs() << "Bind table:\n";
if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
printMachOBindTable(MachO);
else {
errs() << "This operation is only currently supported "
"for Mach-O executable files.\n";
return;
}
}
void llvm::printLazyBindTable(ObjectFile *o) {
outs() << "Lazy bind table:\n";
if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
printMachOLazyBindTable(MachO);
else {
errs() << "This operation is only currently supported "
"for Mach-O executable files.\n";
return;
}
}
void llvm::printWeakBindTable(ObjectFile *o) {
outs() << "Weak bind table:\n";
if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
printMachOWeakBindTable(MachO);
else {
errs() << "This operation is only currently supported "
"for Mach-O executable files.\n";
return;
}
}
/// Dump the raw contents of the __clangast section so the output can be piped
/// into llvm-bcanalyzer.
void llvm::printRawClangAST(const ObjectFile *Obj) {
if (outs().is_displayed()) {
errs() << "The -raw-clang-ast option will dump the raw binary contents of "
"the clang ast section.\n"
"Please redirect the output to a file or another program such as "
"llvm-bcanalyzer.\n";
return;
}
StringRef ClangASTSectionName("__clangast");
if (isa<COFFObjectFile>(Obj)) {
ClangASTSectionName = "clangast";
}
Optional<object::SectionRef> ClangASTSection;
for (auto Sec : ToolSectionFilter(*Obj)) {
StringRef Name;
Sec.getName(Name);
if (Name == ClangASTSectionName) {
ClangASTSection = Sec;
break;
}
}
if (!ClangASTSection)
return;
StringRef ClangASTContents;
error(ClangASTSection.getValue().getContents(ClangASTContents));
outs().write(ClangASTContents.data(), ClangASTContents.size());
}
static void printFaultMaps(const ObjectFile *Obj) {
const char *FaultMapSectionName = nullptr;
if (isa<ELFObjectFileBase>(Obj)) {
FaultMapSectionName = ".llvm_faultmaps";
} else if (isa<MachOObjectFile>(Obj)) {
FaultMapSectionName = "__llvm_faultmaps";
} else {
errs() << "This operation is only currently supported "
"for ELF and Mach-O executable files.\n";
return;
}
Optional<object::SectionRef> FaultMapSection;
for (auto Sec : ToolSectionFilter(*Obj)) {
StringRef Name;
Sec.getName(Name);
if (Name == FaultMapSectionName) {
FaultMapSection = Sec;
break;
}
}
outs() << "FaultMap table:\n";
if (!FaultMapSection.hasValue()) {
outs() << "<not found>\n";
return;
}
StringRef FaultMapContents;
error(FaultMapSection.getValue().getContents(FaultMapContents));
FaultMapParser FMP(FaultMapContents.bytes_begin(),
FaultMapContents.bytes_end());
outs() << FMP;
}
static void printPrivateFileHeaders(const ObjectFile *o, bool onlyFirst) {
if (o->isELF())
return printELFFileHeader(o);
if (o->isCOFF())
return printCOFFFileHeader(o);
if (o->isWasm())
return printWasmFileHeader(o);
if (o->isMachO()) {
printMachOFileHeader(o);
if (!onlyFirst)
printMachOLoadCommands(o);
return;
}
report_error(o->getFileName(), "Invalid/Unsupported object file format");
}
static void DumpObject(ObjectFile *o, const Archive *a = nullptr) {
StringRef ArchiveName = a != nullptr ? a->getFileName() : "";
bool PrintAll =
(cl::getRegisteredOptions()["print-after-all"]->getNumOccurrences() > 0);
// Avoid other output when using a raw option.
if (!RawClangAST && PrintAll) {
outs() << '\n';
if (a)
outs() << a->getFileName() << "(" << o->getFileName() << ")";
else
outs() << "; " << o->getFileName();
outs() << ":\tfile format " << o->getFileFormatName() << "\n\n";
}
if (Disassemble)
DisassembleObject(o, Relocations);
if (SectionHeaders)
PrintSectionHeaders(o);
if (SymbolTable)
PrintSymbolTable(o, ArchiveName);
if (UnwindInfo)
PrintUnwindInfo(o);
if (PrivateHeaders || FirstPrivateHeader)
printPrivateFileHeaders(o, FirstPrivateHeader);
if (ExportsTrie)
printExportsTrie(o);
if (Rebase)
printRebaseTable(o);
if (Bind)
printBindTable(o);
if (LazyBind)
printLazyBindTable(o);
if (WeakBind)
printWeakBindTable(o);
if (RawClangAST)
printRawClangAST(o);
if (PrintFaultMaps)
printFaultMaps(o);
}
static void DumpObject(const COFFImportFile *I, const Archive *A) {
StringRef ArchiveName = A ? A->getFileName() : "";
// Avoid other output when using a raw option.
if (!RawClangAST)
outs() << '\n'
<< ArchiveName << "(" << I->getFileName() << ")"
<< ":\tfile format COFF-import-file"
<< "\n\n";
if (SymbolTable)
printCOFFSymbolTable(I);
}
/// @brief Dump each object file in \a a;
static void DumpArchive(const Archive *a) {
Error Err = Error::success();
for (auto &C : a->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
report_error(a->getFileName(), C, std::move(E));
continue;
}
if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get()))
DumpObject(o, a);
else if (COFFImportFile *I = dyn_cast<COFFImportFile>(&*ChildOrErr.get()))
DumpObject(I, a);
else
report_error(a->getFileName(), object_error::invalid_file_type);
}
if (Err)
report_error(a->getFileName(), std::move(Err));
}
/// @brief Open file and figure out how to dump it.
static void DumpInput(StringRef file) {
// If we are using the Mach-O specific object file parser, then let it parse
// the file and process the command line options. So the -arch flags can
// be used to select specific slices, etc.
if (MachOOpt) {
ParseInputMachO(file);
return;
}
// Attempt to open the binary.
Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(file);
if (!BinaryOrErr)
report_error(file, BinaryOrErr.takeError());
Binary &Binary = *BinaryOrErr.get().getBinary();
if (Archive *a = dyn_cast<Archive>(&Binary))
DumpArchive(a);
else if (ObjectFile *o = dyn_cast<ObjectFile>(&Binary))
DumpObject(o);
else
report_error(file, object_error::invalid_file_type);
}
int main(int argc, char **argv) {
// Print a stack trace if we signal out.
sys::PrintStackTraceOnErrorSignal(argv[0]);
PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
// Initialize targets and assembly printers/parsers.
llvm::InitializeAllTargets();
llvm::InitializeAllTargetInfos();
llvm::InitializeAllTargetMCs();
llvm::InitializeAllDisassemblers();
// Register the target printer for --version.
cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
cl::HideUnrelatedOptions(LLVMMCToLLCategory);
StringMap<cl::Option *> &Map = cl::getRegisteredOptions();
// Unhide print-after-all option and place it in LLVMMCToLLCategory
// Change its help string value appropriately
assert(Map.count("print-after-all") > 0);
Map["print-after-all"]->setHiddenFlag(cl::NotHidden);
Map["print-after-all"]->setCategory(LLVMMCToLLCategory);
Map["print-after-all"]->setDescription("Print IR after each raiser pass");
cl::ParseCommandLineOptions(argc, argv, "MC to LLVM IR dumper\n");
ToolName = argv[0];
// Defaults to a.out if no filenames specified.
if (InputFilenames.size() == 0)
InputFilenames.push_back("a.out");
if (/* DisassembleAll || */ PrintSource || PrintLines)
Disassemble = true;
if (!Disassemble && !Relocations &&
!SectionHeaders
//&& !SectionContents
&& !SymbolTable && !UnwindInfo && !PrivateHeaders &&
!FirstPrivateHeader && !ExportsTrie && !Rebase && !Bind && !LazyBind &&
!WeakBind && !RawClangAST && !(UniversalHeaders && MachOOpt) &&
!(ArchiveHeaders && MachOOpt) && !(IndirectSymbols && MachOOpt) &&
!(DataInCode && MachOOpt) && !(LinkOptHints && MachOOpt) &&
!(InfoPlist && MachOOpt) && !(DylibsUsed && MachOOpt) &&
!(DylibId && MachOOpt) && !(ObjcMetaData && MachOOpt) &&
!(FilterSections.size() != 0 && MachOOpt) && !PrintFaultMaps) {
cl::PrintHelpMessage();
return 2;
}
std::for_each(InputFilenames.begin(), InputFilenames.end(), DumpInput);
return EXIT_SUCCESS;
}

tools/llvm-mctoll/test/CMakeLists.txt

  • This file was added.
# Test runner infrastructure for LLVM-mctoll. This configures the LLVM-mctoll
# test trees for use by Lit, and delegates to LLVM's lit test handlers.
if (CMAKE_CFG_INTDIR STREQUAL ".")
set(LLVM_BUILD_MODE ".")
else ()
set(LLVM_BUILD_MODE "%(build_mode)s")
endif ()
string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} LLVM_MCTOLL_TOOLS_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
set(LLVM_MCTEST_DEPENDS llvm-mctoll)
if (NOT LLVM_MCTOLL_BUILT_STANDALONE)
list(APPEND
LLVM_MCTEST_DEPENDS
clang count FileCheck llc lli llvm-as llvm-cat llvm-dis llvm-mc not opt)
endif()
configure_lit_site_cfg(
${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
)
add_lit_testsuite(check-mctoll "Running the llvm-mctoll tests"
${CMAKE_CURRENT_BINARY_DIR}
PARAMS llvm_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
llvm_unit_site_config=${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
DEPENDS ${LLVM_MCTEST_DEPENDS}
)
set_target_properties(check-mctoll PROPERTIES FOLDER "llvm-mctoll tests")

tools/llvm-mctoll/test/dhrystone/README

  • This file was added.
Dhrystone sources and test script
1. dhry_funcs_mod.c - contains functions that can be successfully
raised and tested for execution correctness.
2. dhry_main.c - contains main function and other functions whose
raised results need to be tested for execution correctness.
3. dhry.h - Unmodified header file.
4. README - for notes about the test
NOTE: switch statement in Proc_6 has been temporarily changed to if-then-else
No newline at end of file

tools/llvm-mctoll/test/dhrystone/dhry.h

  • This file was added.
/*
****************************************************************************
*
* "DHRYSTONE" Benchmark Program
* -----------------------------
*
* Version: C, Version 2.1
*
* File: dhry.h (part 1 of 3)
*
* Date: May 25, 1988
*
* Author: Reinhold P. Weicker
* Siemens AG, E STE 35
* Postfach 3240
* 8520 Erlangen
* Germany (West)
* Phone: [xxx-49]-9131-7-20330
* (8-17 Central European Time)
* Usenet: ..!mcvax!unido!estevax!weicker
*
* Original Version (in Ada) published in
* "Communications of the ACM" vol. 27., no. 10 (Oct. 1984),
* pp. 1013 - 1030, together with the statistics
* on which the distribution of statements etc. is based.
*
* In this C version, the following C library functions are used:
* - strcpy, strcmp (inside the measurement loop)
* - printf, scanf (outside the measurement loop)
* In addition, Berkeley UNIX system calls "times ()" or "time ()"
* are used for execution time measurement. For measurements
* on other systems, these calls have to be changed.
*
* Collection of Results:
* Reinhold Weicker (address see above) and
*
* Rick Richardson
* PC Research. Inc.
* 94 Apple Orchard Drive
* Tinton Falls, NJ 07724
* Phone: (201) 389-8963 (9-17 EST)
* Usenet: ...!uunet!pcrat!rick
*
* Please send results to Rick Richardson and/or Reinhold Weicker.
* Complete information should be given on hardware and software used.
* Hardware information includes: Machine type, CPU, type and size
* of caches; for microprocessors: clock frequency, memory speed
* (number of wait states).
* Software information includes: Compiler (and runtime library)
* manufacturer and version, compilation switches, OS version.
* The Operating System version may give an indication about the
* compiler; Dhrystone itself performs no OS calls in the measurement loop.
*
* The complete output generated by the program should be mailed
* such that at least some checks for correctness can be made.
*
***************************************************************************
*
* History: This version C/2.1 has been made for two reasons:
*
* 1) There is an obvious need for a common C version of
* Dhrystone, since C is at present the most popular system
* programming language for the class of processors
* (microcomputers, minicomputers) where Dhrystone is used most.
* There should be, as far as possible, only one C version of
* Dhrystone such that results can be compared without
* restrictions. In the past, the C versions distributed
* by Rick Richardson (Version 1.1) and by Reinhold Weicker
* had small (though not significant) differences.
*
* 2) As far as it is possible without changes to the Dhrystone
* statistics, optimizing compilers should be prevented from
* removing significant statements.
*
* This C version has been developed in cooperation with
* Rick Richardson (Tinton Falls, NJ), it incorporates many
* ideas from the "Version 1.1" distributed previously by
* him over the UNIX network Usenet.
* I also thank Chaim Benedelac (National Semiconductor),
* David Ditzel (SUN), Earl Killian and John Mashey (MIPS),
* Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley)
* for their help with comments on earlier versions of the
* benchmark.
*
* Changes: In the initialization part, this version follows mostly
* Rick Richardson's version distributed via Usenet, not the
* version distributed earlier via floppy disk by Reinhold Weicker.
* As a concession to older compilers, names have been made
* unique within the first 8 characters.
* Inside the measurement loop, this version follows the
* version previously distributed by Reinhold Weicker.
*
* At several places in the benchmark, code has been added,
* but within the measurement loop only in branches that
* are not executed. The intention is that optimizing compilers
* should be prevented from moving code out of the measurement
* loop, or from removing code altogether. Since the statements
* that are executed within the measurement loop have NOT been
* changed, the numbers defining the "Dhrystone distribution"
* (distribution of statements, operand types and locality)
* still hold. Except for sophisticated optimizing compilers,
* execution times for this version should be the same as
* for previous versions.
*
* Since it has proven difficult to subtract the time for the
* measurement loop overhead in a correct way, the loop check
* has been made a part of the benchmark. This does have
* an impact - though a very minor one - on the distribution
* statistics which have been updated for this version.
*
* All changes within the measurement loop are described
* and discussed in the companion paper "Rationale for
* Dhrystone version 2".
*
* Because of the self-imposed limitation that the order and
* distribution of the executed statements should not be
* changed, there are still cases where optimizing compilers
* may not generate code for some statements. To a certain
* degree, this is unavoidable for small synthetic benchmarks.
* Users of the benchmark are advised to check code listings
* whether code is generated for all statements of Dhrystone.
*
* Version 2.1 is identical to version 2.0 distributed via
* the UNIX network Usenet in March 1988 except that it corrects
* some minor deficiencies that were found by users of version 2.0.
* The only change within the measurement loop is that a
* non-executed "else" part was added to the "if" statement in
* Func_3, and a non-executed "else" part removed from Proc_3.
*
***************************************************************************
*
* Defines: The following "Defines" are possible:
* -DREG=register (default: Not defined)
* As an approximation to what an average C programmer
* might do, the "register" storage class is applied
* (if enabled by -DREG=register)
* - for local variables, if they are used (dynamically)
* five or more times
* - for parameters if they are used (dynamically)
* six or more times
* Note that an optimal "register" strategy is
* compiler-dependent, and that "register" declarations
* do not necessarily lead to faster execution.
* -DNOSTRUCTASSIGN (default: Not defined)
* Define if the C compiler does not support
* assignment of structures.
* -DNOENUMS (default: Not defined)
* Define if the C compiler does not support
* enumeration types.
* -DTIMES (default)
* -DTIME
* The "times" function of UNIX (returning process times)
* or the "time" function (returning wallclock time)
* is used for measurement.
* For single user machines, "time ()" is adequate. For
* multi-user machines where you cannot get single-user
* access, use the "times ()" function. If you have
* neither, use a stopwatch in the dead of night.
* "printf"s are provided marking the points "Start Timer"
* and "Stop Timer". DO NOT use the UNIX "time(1)"
* command, as this will measure the total time to
* run this program, which will (erroneously) include
* the time to allocate storage (malloc) and to perform
* the initialization.
* -DHZ=nnn
* In Berkeley UNIX, the function "times" returns process
* time in 1/HZ seconds, with HZ = 60 for most systems.
* CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY
* A VALUE.
*
***************************************************************************
*
* Compilation model and measurement (IMPORTANT):
*
* This C version of Dhrystone consists of three files:
* - dhry.h (this file, containing global definitions and comments)
* - dhry_1.c (containing the code corresponding to Ada package Pack_1)
* - dhry_2.c (containing the code corresponding to Ada package Pack_2)
*
* The following "ground rules" apply for measurements:
* - Separate compilation
* - No procedure merging
* - Otherwise, compiler optimizations are allowed but should be indicated
* - Default results are those without register declarations
* See the companion paper "Rationale for Dhrystone Version 2" for a more
* detailed discussion of these ground rules.
*
* For 16-Bit processors (e.g. 80186, 80286), times for all compilation
* models ("small", "medium", "large" etc.) should be given if possible,
* together with a definition of these models for the compiler system used.
*
**************************************************************************
*
* Dhrystone (C version) statistics:
*
* [Comment from the first distribution, updated for version 2.
* Note that because of language differences, the numbers are slightly
* different from the Ada version.]
*
* The following program contains statements of a high level programming
* language (here: C) in a distribution considered representative:
*
* assignments 52 (51.0 %)
* control statements 33 (32.4 %)
* procedure, function calls 17 (16.7 %)
*
* 103 statements are dynamically executed. The program is balanced with
* respect to the three aspects:
*
* - statement type
* - operand type
* - operand locality
* operand global, local, parameter, or constant.
*
* The combination of these three aspects is balanced only approximately.
*
* 1. Statement Type:
* ----------------- number
*
* V1 = V2 9
* (incl. V1 = F(..)
* V = Constant 12
* Assignment, 7
* with array element
* Assignment, 6
* with record component
* --
* 34 34
*
* X = Y +|-|"&&"|"|" Z 5
* X = Y +|-|"==" Constant 6
* X = X +|- 1 3
* X = Y *|/ Z 2
* X = Expression, 1
* two operators
* X = Expression, 1
* three operators
* --
* 18 18
*
* if .... 14
* with "else" 7
* without "else" 7
* executed 3
* not executed 4
* for ... 7 | counted every time
* while ... 4 | the loop condition
* do ... while 1 | is evaluated
* switch ... 1
* break 1
* declaration with 1
* initialization
* --
* 34 34
*
* P (...) procedure call 11
* user procedure 10
* library procedure 1
* X = F (...)
* function call 6
* user function 5
* library function 1
* --
* 17 17
* ---
* 103
*
* The average number of parameters in procedure or function calls
* is 1.82 (not counting the function values aX *
*
* 2. Operators
* ------------
* number approximate
* percentage
*
* Arithmetic 32 50.8
*
* + 21 33.3
* - 7 11.1
* * 3 4.8
* / (int div) 1 1.6
*
* Comparison 27 42.8
*
* == 9 14.3
* /= 4 6.3
* > 1 1.6
* < 3 4.8
* >= 1 1.6
* <= 9 14.3
*
* Logic 4 6.3
*
* && (AND-THEN) 1 1.6
* | (OR) 1 1.6
* ! (NOT) 2 3.2
*
* -- -----
* 63 100.1
*
*
* 3. Operand Type (counted once per operand reference):
* ---------------
* number approximate
* percentage
*
* Integer 175 72.3 %
* Character 45 18.6 %
* Pointer 12 5.0 %
* String30 6 2.5 %
* Array 2 0.8 %
* Record 2 0.8 %
* --- -------
* 242 100.0 %
*
* When there is an access path leading to the final operand (e.g. a record
* component), only the final data type on the access path is counted.
*
*
* 4. Operand Locality:
* -------------------
* number approximate
* percentage
*
* local variable 114 47.1 %
* global variable 22 9.1 %
* parameter 45 18.6 %
* value 23 9.5 %
* reference 22 9.1 %
* function result 6 2.5 %
* constant 55 22.7 %
* --- -------
* 242 100.0 %
*
*
* The program does not compute anything meaningful, but it is syntactically
* and semantically correct. All variables have a value assigned to them
* before they are used as a source operand.
*
* There has been no explicit effort to account for the effects of a
* cache, or to balance the use of long or short displacements for code or
* data.
*
***************************************************************************
*/
/* Compiler and system dependent definitions: */
#ifndef TIME
#undef TIMES
#define TIMES
#endif
/* Use times(2) time function unless */
/* explicitly defined otherwise */
#ifdef MSC_CLOCK
#undef HZ
#undef TIMES
#include <time.h>
#define HZ CLK_TCK
#endif
/* Use Microsoft C hi-res clock */
#ifdef TIMES
#include <sys/types.h>
#include <sys/times.h>
/* for "times" */
#endif
#define Mic_secs_Per_Second 1000000.0
/* Berkeley UNIX C returns process times in seconds/HZ */
#ifdef NOSTRUCTASSIGN
#define structassign(d, s) libc_memcpy(&(d), &(s), sizeof(d))
#else
#define structassign(d, s) d = s
#endif
#ifdef NOENUM
#define Ident_1 0
#define Ident_2 1
#define Ident_3 2
#define Ident_4 3
#define Ident_5 4
typedef int Enumeration;
#else
typedef enum {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5}
Enumeration;
#endif
/* for boolean and enumeration types in Ada, Pascal */
/* General definitions: */
#include <stdio.h>
/* for strcpy, strcmp */
#define Null 0
/* Value of a Null pointer */
#define true 1
#define false 0
typedef int One_Thirty;
typedef int One_Fifty;
typedef char Capital_Letter;
typedef int Boolean;
typedef char Str_30 [31];
typedef int Arr_1_Dim [50];
typedef int Arr_2_Dim [50] [50];
typedef struct record
{
struct record *Ptr_Comp;
Enumeration Discr;
union {
struct {
Enumeration Enum_Comp;
int Int_Comp;
char Str_Comp [31];
} var_1;
struct {
Enumeration E_Comp_2;
char Str_2_Comp [31];
} var_2;
struct {
char Ch_1_Comp;
char Ch_2_Comp;
} var_3;
} variant;
} Rec_Type, *Rec_Pointer;

tools/llvm-mctoll/test/dhrystone/dhry.test

  • This file was added.
// RUN: clang -o %t.so %S/dhry_funcs_mod.c -shared -fPIC -g -DTIME -DHZ=2133 -DNOSTRUCTASSIGN
// RUN: llvm-mctoll -d %t.so
// RUN: clang -o %t1 %S/dhry_main.c %t-dis.ll -DTIME -DHZ=2133 -DNOSTRUCTASSIGN
// RUN: %t1 2>&1| FileCheck %s
// CHECK: Dhrystone Benchmark, Version 2.1 (Language: C)
// CHECK: Program compiled without 'register' attribute
// CHECK: Execution starts, 100000000 runs through Dhrystone
// CHECK: Execution ends
// CHECK: Final values of the variables used in the benchmark:
// CHECK: Int_Glob: 5
// CHECK: Bool_Glob: 1
// CHECK: Ch_1_Glob: A
// CHECK: Ch_2_Glob: B
// CHECK: Arr_1_Glob[8]: 7
// CHECK: Arr_2_Glob[8][7]: 100000010
// CHECK: Ptr_Glob->
// CHECK: Ptr_Comp: {{[0-9]+}}
// CHECK: Discr: 0
// CHECK: Enum_Comp: 2
// CHECK: Int_Comp: 17
// CHECK: Str_Comp: DHRYSTONE PROGRAM, SOME STRING
// CHECK: Next_Ptr_Glob->
// CHECK: Ptr_Comp: {{[0-9]+}}
// CHECK: Discr: 0
// CHECK: Enum_Comp: 1
// CHECK: Int_Comp: 18
// CHECK: Str_Comp: DHRYSTONE PROGRAM, SOME STRING
// CHECK: Int_1_Loc: 5
// CHECK: Int_2_Loc: 13
// CHECK: Int_3_Loc: 7
// CHECK: Enum_Loc: 1
// CHECK: Str_1_Loc: DHRYSTONE PROGRAM, 1'ST STRING
// CHECK: Str_2_Loc: DHRYSTONE PROGRAM, 2'ND STRING
// CHECK: Microseconds for one run through Dhrystone: {{[0-9]+}}.{{[0-9]+}}
// CHECK: Dhrystones per Second: {{[0-9]+}}.{{[0-9]+}}
No newline at end of file

tools/llvm-mctoll/test/dhrystone/dhry_funcs_mod.c

  • This file was added.
/*
****************************************************************************
*
* "DHRYSTONE" Benchmark Program
* -----------------------------
*
* Version: C, Version 2.1
*
* File: dhry_2.c (part 3 of 3)
*
* Date: May 25, 1988
*
* Author: Reinhold P. Weicker
*
****************************************************************************
*/
#include "dhry.h"
#ifndef REG
#define REG
/* REG becomes defined as empty */
/* i.e. no register variables */
#endif
int Int_Glob;
char Ch_1_Glob;
char Ch_2_Glob;
Boolean Bool_Glob;
Rec_Pointer Ptr_Glob;
Proc_4 () /* without parameters */
/*******/
/* executed once */
{
Boolean Bool_Loc;
Bool_Loc = Ch_1_Glob == 'A';
Bool_Glob = Bool_Loc | Bool_Glob;
Ch_2_Glob = 'B';
} /* Proc_4 */
Proc_5 () /* without parameters */
/*******/
/* executed once */
{
Ch_1_Glob = 'A';
Bool_Glob = false;
} /* Proc_5 */
Proc_3 (Ptr_Ref_Par)
/******************/
/* executed once */
/* Ptr_Ref_Par becomes Ptr_Glob */
Rec_Pointer *Ptr_Ref_Par;
{
if (Ptr_Glob != Null)
/* then, executed */
*Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
} /* Proc_3 */
Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref)
/**********************************************/
/* executed three times */
/* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */
/* Int_Par_Ref becomes 7 */
/* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
/* Int_Par_Ref becomes 17 */
/* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
/* Int_Par_Ref becomes 18 */
One_Fifty Int_1_Par_Val;
One_Fifty Int_2_Par_Val;
One_Fifty *Int_Par_Ref;
{
One_Fifty Int_Loc;
Int_Loc = Int_1_Par_Val + 2;
*Int_Par_Ref = Int_2_Par_Val + Int_Loc;
} /* Proc_7 */
Proc_2 (Int_Par_Ref)
/******************/
/* executed once */
/* *Int_Par_Ref == 1, becomes 4 */
One_Fifty *Int_Par_Ref;
{
One_Fifty Int_Loc;
Enumeration Enum_Loc;
Int_Loc = *Int_Par_Ref + 10;
do /* executed once */
if (Ch_1_Glob == 'A')
/* then, executed */
{
Int_Loc -= 1;
*Int_Par_Ref = Int_Loc - Int_Glob;
Enum_Loc = Ident_1;
} /* if */
while (Enum_Loc != Ident_1); /* true */
} /* Proc_2 */
Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val)
/*********************************************************************/
/* executed once */
/* Int_Par_Val_1 == 3 */
/* Int_Par_Val_2 == 7 */
Arr_1_Dim Arr_1_Par_Ref;
Arr_2_Dim Arr_2_Par_Ref;
int Int_1_Par_Val;
int Int_2_Par_Val;
{
REG One_Fifty Int_Index;
REG One_Fifty Int_Loc;
Int_Loc = Int_1_Par_Val + 5;
Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1;
Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
Int_Glob = 5;
} /* Proc_8 */
/* Procedure for the assignment of structures, */
/* if the C compiler doesn't support this feature */
#ifdef NOSTRUCTASSIGN
libc_memcpy (d, s, l)
register char *d;
register char *s;
register int l;
{
while (l--) *d++ = *s++;
}
#endif
/* Compare S1 and S2, returning less than, equal to or
greater than zero if S1 is lexicographically less than,
equal to or greater than S2. */
int
libc_strcmp (p1, p2)
const char *p1;
const char *p2;
{
const unsigned char *s1 = (const unsigned char *) p1;
const unsigned char *s2 = (const unsigned char *) p2;
unsigned char c1, c2;
do
{
c1 = (unsigned char) *s1++;
c2 = (unsigned char) *s2++;
if (c1 == '\0')
return c1 - c2;
}
while (c1 == c2);
return c1 - c2;
}
/*******************************/
Proc_6 (Enum_Val_Par, Enum_Ref_Par)
/*********************************/
/* executed once */
/* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
Enumeration Enum_Val_Par;
Enumeration *Enum_Ref_Par;
{
*Enum_Ref_Par = Enum_Val_Par;
if (! Func_3 (Enum_Val_Par))
/* then, not executed */
*Enum_Ref_Par = Ident_4;
#if 0
switch (Enum_Val_Par)
{
case Ident_1:
*Enum_Ref_Par = Ident_1;
break;
case Ident_2:
if (Int_Glob > 100)
/* then */
*Enum_Ref_Par = Ident_1;
else *Enum_Ref_Par = Ident_4;
break;
case Ident_3: /* executed */
*Enum_Ref_Par = Ident_2;
break;
case Ident_4: break;
case Ident_5:
*Enum_Ref_Par = Ident_3;
break;
} /* switch */
#endif
if (Enum_Val_Par == Ident_1) {
*Enum_Ref_Par = Ident_1;
} else if (Enum_Val_Par == Ident_2) {
if (Int_Glob > 100)
/* then */
*Enum_Ref_Par = Ident_1;
else *Enum_Ref_Par = Ident_4;
} else if (Enum_Val_Par == Ident_3) { /* executed */
*Enum_Ref_Par = Ident_2;
} else if (Enum_Val_Par == Ident_4) {
} else if (Enum_Val_Par == Ident_5) {
*Enum_Ref_Par = Ident_3;
}
} /* Proc_6 */
Boolean Func_3 (Enum_Par_Val)
/***************************/
/* executed once */
/* Enum_Par_Val == Ident_3 */
Enumeration Enum_Par_Val;
{
Enumeration Enum_Loc;
Enum_Loc = Enum_Par_Val;
if (Enum_Loc == Ident_3)
/* then, executed */
return (true);
else /* not executed */
return (false);
} /* Func_3 */
Enumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val)
/*************************************************/
/* executed three times */
/* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */
/* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */
/* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */
Capital_Letter Ch_1_Par_Val;
Capital_Letter Ch_2_Par_Val;
{
Capital_Letter Ch_1_Loc;
Capital_Letter Ch_2_Loc;
Ch_1_Loc = Ch_1_Par_Val;
Ch_2_Loc = Ch_1_Loc;
if (Ch_2_Loc != Ch_2_Par_Val)
/* then, executed */
return (Ident_1);
else /* not executed */
{
Ch_1_Glob = Ch_1_Loc;
return (Ident_2);
}
} /* Func_1 */
Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref)
/*************************************************/
/* executed once */
/* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
/* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
Str_30 Str_1_Par_Ref;
Str_30 Str_2_Par_Ref;
{
REG One_Thirty Int_Loc;
Capital_Letter Ch_Loc;
Int_Loc = 2;
while (Int_Loc <= 2) /* loop body executed once */
if (Func_1 (Str_1_Par_Ref[Int_Loc],
Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
/* then, executed */
{
Ch_Loc = 'A';
Int_Loc += 1;
} /* if, while */
if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
/* then, not executed */
Int_Loc = 7;
if (Ch_Loc == 'R')
/* then, not executed */
return (true);
else /* executed */
{
if (libc_strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
/* then, not executed */
{
Int_Loc += 7;
Int_Glob = Int_Loc;
return (true);
}
else /* executed */
return (false);
} /* if Ch_Loc */
} /* Func_2 */
Proc_1 (Ptr_Val_Par)
/******************/
REG Rec_Pointer Ptr_Val_Par;
/* executed once */
{
REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;
/* == Ptr_Glob_Next */
/* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */
/* corresponds to "rename" in Ada, "with" in Pascal */
structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
Ptr_Val_Par->variant.var_1.Int_Comp = 5;
Next_Record->variant.var_1.Int_Comp
= Ptr_Val_Par->variant.var_1.Int_Comp;
Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
Proc_3 (&Next_Record->Ptr_Comp);
/* Ptr_Val_Par->Ptr_Comp->Ptr_Comp
== Ptr_Glob->Ptr_Comp */
if (Next_Record->Discr == Ident_1)
/* then, executed */
{
Next_Record->variant.var_1.Int_Comp = 6;
Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp,
&Next_Record->variant.var_1.Enum_Comp);
Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
Proc_7 (Next_Record->variant.var_1.Int_Comp, 10,
&Next_Record->variant.var_1.Int_Comp);
}
else /* not executed */
structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
} /* Proc_1 */

tools/llvm-mctoll/test/dhrystone/dhry_main.c

  • This file was added.
/*
****************************************************************************
*
* "DHRYSTONE" Benchmark Program
* -----------------------------
*
* Version: C, Version 2.1
*
* File: dhry_1.c (part 2 of 3)
*
* Date: May 25, 1988
*
* Author: Reinhold P. Weicker
*
****************************************************************************
*/
#include "dhry.h"
/* Global Variables: */
extern int Int_Glob;
extern char Ch_1_Glob;
extern Rec_Pointer Ptr_Glob;
Rec_Pointer Next_Ptr_Glob;
extern Boolean Bool_Glob;
extern char Ch_2_Glob;
int Arr_1_Glob [50];
int Arr_2_Glob [50] [50];
extern char *malloc ();
Enumeration Func_1 ();
/* forward declaration necessary since Enumeration may not simply be int */
#ifndef REG
Boolean Reg = false;
#define REG
/* REG becomes defined as empty */
/* i.e. no register variables */
#else
Boolean Reg = true;
#endif
/* variables for time measurement: */
#ifdef TIMES
struct tms time_info;
extern int times ();
/* see library function "times" */
#define Too_Small_Time (2*HZ)
/* Measurements should last at least about 2 seconds */
#endif
#ifdef TIME
extern long time();
/* see library function "time" */
#define Too_Small_Time 2
/* Measurements should last at least 2 seconds */
#endif
#ifdef MSC_CLOCK
extern clock_t clock();
#define Too_Small_Time (2*HZ)
#endif
long Begin_Time,
End_Time,
User_Time;
float Microseconds,
Dhrystones_Per_Second;
/* end of variables for time measurement */
main ()
/*****/
/* main program, corresponds to procedures */
/* Main and Proc_0 in the Ada version */
{
One_Fifty Int_1_Loc;
REG One_Fifty Int_2_Loc;
One_Fifty Int_3_Loc;
REG char Ch_Index;
Enumeration Enum_Loc;
Str_30 Str_1_Loc;
Str_30 Str_2_Loc;
REG int Run_Index;
// A value is specifed for testing purposes
REG int Number_Of_Runs = 100000000;
/* Initializations */
Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
Ptr_Glob->Ptr_Comp = Next_Ptr_Glob;
Ptr_Glob->Discr = Ident_1;
Ptr_Glob->variant.var_1.Enum_Comp = Ident_3;
Ptr_Glob->variant.var_1.Int_Comp = 40;
strcpy (Ptr_Glob->variant.var_1.Str_Comp,
"DHRYSTONE PROGRAM, SOME STRING");
strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
Arr_2_Glob [8][7] = 10;
/* Was missing in published program. Without this statement, */
/* Arr_2_Glob [8][7] would have an undefined value. */
/* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */
/* overflow may occur for this array element. */
printf ("\n");
printf ("Dhrystone Benchmark, Version 2.1 (Language: C)\n");
printf ("\n");
if (Reg)
{
printf ("Program compiled with 'register' attribute\n");
printf ("\n");
}
else
{
printf ("Program compiled without 'register' attribute\n");
printf ("\n");
}
#if 0
// This is commented out and the number of runs is specified as a constant
printf ("Please give the number of runs through the benchmark: ");
{
int n;
scanf ("%d", &n);
Number_Of_Runs = n;
}
#endif
printf ("\n");
printf ("Execution starts, %d runs through Dhrystone\n", Number_Of_Runs);
/***************/
/* Start timer */
/***************/
#ifdef TIMES
times (&time_info);
Begin_Time = (long) time_info.tms_utime;
#endif
#ifdef TIME
Begin_Time = time ( (long *) 0);
#endif
#ifdef MSC_CLOCK
Begin_Time = clock();
#endif
for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
{
Proc_5();
Proc_4();
/* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
Int_1_Loc = 2;
Int_2_Loc = 3;
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
Enum_Loc = Ident_2;
Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
/* Bool_Glob == 1 */
while (Int_1_Loc < Int_2_Loc) /* loop body executed once */
{
Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
/* Int_3_Loc == 7 */
Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
/* Int_3_Loc == 7 */
Int_1_Loc += 1;
} /* while */
/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
/* Int_Glob == 5 */
Proc_1 (Ptr_Glob);
for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
/* loop body executed twice */
{
if (Enum_Loc == Func_1 (Ch_Index, 'C'))
/* then, not executed */
{
Proc_6 (Ident_1, &Enum_Loc);
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
Int_2_Loc = Run_Index;
Int_Glob = Run_Index;
}
}
/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
Int_2_Loc = Int_2_Loc * Int_1_Loc;
Int_1_Loc = Int_2_Loc / Int_3_Loc;
Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
/* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
Proc_2 (&Int_1_Loc);
/* Int_1_Loc == 5 */
} /* loop "for Run_Index" */
/**************/
/* Stop timer */
/**************/
#ifdef TIMES
times (&time_info);
End_Time = (long) time_info.tms_utime;
#endif
#ifdef TIME
End_Time = time ( (long *) 0);
#endif
#ifdef MSC_CLOCK
End_Time = clock();
#endif
printf ("Execution ends\n");
printf ("\n");
printf ("Final values of the variables used in the benchmark:\n");
printf ("\n");
printf ("Int_Glob: %d\n", Int_Glob);
printf (" should be: %d\n", 5);
printf ("Bool_Glob: %d\n", Bool_Glob);
printf (" should be: %d\n", 1);
printf ("Ch_1_Glob: %c\n", Ch_1_Glob);
printf (" should be: %c\n", 'A');
printf ("Ch_2_Glob: %c\n", Ch_2_Glob);
printf (" should be: %c\n", 'B');
printf ("Arr_1_Glob[8]: %d\n", Arr_1_Glob[8]);
printf (" should be: %d\n", 7);
printf ("Arr_2_Glob[8][7]: %d\n", Arr_2_Glob[8][7]);
printf (" should be: Number_Of_Runs + 10\n");
printf ("Ptr_Glob->\n");
printf (" Ptr_Comp: %d\n", (int) Ptr_Glob->Ptr_Comp);
printf (" should be: (implementation-dependent)\n");
printf (" Discr: %d\n", Ptr_Glob->Discr);
printf (" should be: %d\n", 0);
printf (" Enum_Comp: %d\n", Ptr_Glob->variant.var_1.Enum_Comp);
printf (" should be: %d\n", 2);
printf (" Int_Comp: %d\n", Ptr_Glob->variant.var_1.Int_Comp);
printf (" should be: %d\n", 17);
printf (" Str_Comp: %s\n", Ptr_Glob->variant.var_1.Str_Comp);
printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
printf ("Next_Ptr_Glob->\n");
printf (" Ptr_Comp: %d\n", (int) Next_Ptr_Glob->Ptr_Comp);
printf (" should be: (implementation-dependent), same as above\n");
printf (" Discr: %d\n", Next_Ptr_Glob->Discr);
printf (" should be: %d\n", 0);
printf (" Enum_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp);
printf (" should be: %d\n", 1);
printf (" Int_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp);
printf (" should be: %d\n", 18);
printf (" Str_Comp: %s\n",
Next_Ptr_Glob->variant.var_1.Str_Comp);
printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
printf ("Int_1_Loc: %d\n", Int_1_Loc);
printf (" should be: %d\n", 5);
printf ("Int_2_Loc: %d\n", Int_2_Loc);
printf (" should be: %d\n", 13);
printf ("Int_3_Loc: %d\n", Int_3_Loc);
printf (" should be: %d\n", 7);
printf ("Enum_Loc: %d\n", Enum_Loc);
printf (" should be: %d\n", 1);
printf ("Str_1_Loc: %s\n", Str_1_Loc);
printf (" should be: DHRYSTONE PROGRAM, 1'ST STRING\n");
printf ("Str_2_Loc: %s\n", Str_2_Loc);
printf (" should be: DHRYSTONE PROGRAM, 2'ND STRING\n");
printf ("\n");
User_Time = End_Time - Begin_Time;
if (User_Time < Too_Small_Time)
{
printf ("Measured time too small to obtain meaningful results\n");
printf ("Please increase number of runs\n");
printf ("\n");
}
else
{
#ifdef TIME
Microseconds = (float) User_Time * Mic_secs_Per_Second
/ (float) Number_Of_Runs;
Dhrystones_Per_Second = (float) Number_Of_Runs / (float) User_Time;
#else
Microseconds = (float) User_Time * Mic_secs_Per_Second
/ ((float) HZ * ((float) Number_Of_Runs));
Dhrystones_Per_Second = ((float) HZ * (float) Number_Of_Runs)
/ (float) User_Time;
#endif
printf ("Microseconds for one run through Dhrystone: ");
printf ("%6.1f \n", Microseconds);
printf ("Dhrystones per Second: ");
printf ("%6.1f \n", Dhrystones_Per_Second);
printf ("\n");
}
}

tools/llvm-mctoll/test/dhrystone/lit.local.cfg

  • This file was added.
config.suffixes = ['.test']

tools/llvm-mctoll/test/lit.cfg

  • This file was added.
# -*- Python -*-
# Configuration file for the 'lit' test runner.
import os
import lit.formats
from lit.llvm import llvm_config
# Configuration file for the 'lit' test runner.
# name: The name of this test suite.
config.name = 'mctoll'
# testFormat: The test format to use to interpret tests.
config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
# suffixes: A list of file extensions to treat as test files. This is overriden
# by individual lit.local.cfg files in the test subdirectories.
config.suffixes = []
# excludes: A list of directories or files to exclude from the testsuite even
# if they match the suffixes pattern.
config.excludes = ['Inputs']
# test_source_root: The root path where tests are located.
config.test_source_root = os.path.dirname(__file__)
# test_exec_root: The root path where tests should be run.
config.test_exec_root = os.path.join(config.llvm_mctoll_obj_root, 'test')
# Tweak the PATH to include the tools dir.
llvm_config.with_environment('PATH', config.llvm_tools_dir, append_path=True)
# Propagate some variables from the host environment.
llvm_config.with_system_environment(
['HOME', 'INCLUDE', 'LIB', 'TMP', 'TEMP'])
llvm_config.use_default_substitutions()
# For each occurrence of a tool name, replace it with the full path to
# the build directory holding that tool. We explicitly specify the directories
# to search to ensure that we get the tools just built and not some random
# tools that might happen to be in the user's PATH.
tool_dirs = [config.llvm_mctoll_tools_dir, config.llvm_tools_dir]
tools = [ 'clang', 'llvm-mctoll' ]
llvm_config.add_tool_substitutions(tools, tool_dirs)

tools/llvm-mctoll/test/lit.site.cfg.in

  • This file was added.
@LIT_SITE_CFG_IN_HEADER@
config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
config.llvm_mctoll_obj_root = "@LLVM_MCTOLL_BINARY_DIR@"
config.llvm_mctoll_tools_dir = "@LLVM_MCTOLL_TOOLS_DIR@"
config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
config.target_triple = "@TARGET_TRIPLE@"
# Support substitution of the tools and build_mode with user parameters.
# This is used when we can't determine the tool dir at configuration time.
try:
config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
config.llvm_mctoll_tools_dir = config.llvm_mctoll_tools_dir % lit_config.params
except KeyError as e:
key, = e.args
lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
import lit.llvm
lit.llvm.initialize(lit_config, config)
# Let the main config do the real work.
lit_config.load_config(config, "@LLVM_MCTOLL_SOURCE_DIR@/test/lit.cfg")

tools/llvm-mctoll/test/smoke_test/Inputs/factorial.c

  • This file was added.
int factorial(int n) {
if (n == 0) {
return 1;
}
return n * factorial(n - 1);
}

tools/llvm-mctoll/test/smoke_test/Inputs/fibfunc.c

  • This file was added.
long fib(long n) {
if (n <= 1) {
return 1;
} else {
return fib(n - 1) + fib(n - 2);
}
}

tools/llvm-mctoll/test/smoke_test/Inputs/globalvar.c

  • This file was added.
int myglob = 42;
int myglobal_func(int a, int b)
{
myglob += a;
return b + myglob;
}

tools/llvm-mctoll/test/smoke_test/Inputs/simple-phi.c

  • This file was added.
typedef int bool;
bool orvalues(bool r, bool y) { return (y || r); }

tools/llvm-mctoll/test/smoke_test/Inputs/strcmp.c

  • This file was added.
int libc_strcmp(p1, p2) const char *p1;
const char *p2;
{
const unsigned char *s1 = (const unsigned char *)p1;
const unsigned char *s2 = (const unsigned char *)p2;
unsigned char c1, c2;
do {
c1 = (unsigned char)*s1++;
c2 = (unsigned char)*s2++;
if (c1 == '\0')
return c1 - c2;
} while (c1 == c2);
return c1 - c2;
}

tools/llvm-mctoll/test/smoke_test/Inputs/test-1.c

  • This file was added.
/**
* Compile command : clang -c test-1.c
**/
long test_1_func(int a, long b) { return a + b; }

tools/llvm-mctoll/test/smoke_test/Inputs/test-2.c

  • This file was added.
/**
* Compile command : clang -c test-2.c
**/
long test_2_func(int a, long b) {
int c = a + b;
return a + c;
}

tools/llvm-mctoll/test/smoke_test/Inputs/test-3.c

  • This file was added.
int test_3_func(int a, int b) {
int c = 0;
c = b - a;
return c;
}

tools/llvm-mctoll/test/smoke_test/factorial-test.c

  • This file was added.
// RUN: clang -o %t.so %S/Inputs/factorial.c -shared -fPIC
// RUN: llvm-mctoll -d %t.so
// RUN: clang -o %t1 %s %t-dis.ll
// RUN: %t1 2>&1 | FileCheck %s
// CHECK: Factorial of 10 3628800
#include <stdio.h>
extern int factorial(int n);
int main() {
printf("Factorial of 10 %d\n", factorial(10));
return 0;
}

tools/llvm-mctoll/test/smoke_test/fibfunc-test.c

  • This file was added.
// RUN: clang -o %t.so %S/Inputs/fibfunc.c -shared -fPIC
// RUN: llvm-mctoll -d %t.so
// RUN: clang -o %t1 %s %t-dis.ll
// RUN: %t1 2>&1 | FileCheck %s
// CHECK: Fibonacci of 42 433494437
#include <stdio.h>
extern long fib(long n);
int main() {
printf("Fibonacci of 42 %ld\n", fib(42));
return 0;
}

tools/llvm-mctoll/test/smoke_test/globalvar-test.c

  • This file was added.
// RUN: clang -o %t.so %S/Inputs/globalvar.c -shared -fPIC
// RUN: llvm-mctoll -d %t.so
// RUN: clang -o %t1 %s %t-dis.ll
// RUN: %t1 2>&1 | FileCheck %s
// CHECK: GlobalVar Initial value = 42
// CHECK-NEXT: myglobal_func returns 72
// CHECK-NEXT: GlobalVar updated value = 52
#include <stdio.h>
extern int myglob;
extern int myglobal_func(int a, int b);
int main() {
printf("GlobalVar Initial value = %d\n", myglob);
printf("myglobal_func returns %d\n", myglobal_func(10, 20));
printf("GlobalVar updated value = %d\n", myglob);
return 0;
}

tools/llvm-mctoll/test/smoke_test/hello.c

  • This file was added.
// RUN: clang -o %t %s
// RUN: llvm-mctoll -d %t
// RUN: clang -o %t1 %t-dis.ll
// RUN: %t1 2>&1 | FileCheck %s
// CHECK: Hello world!
#include <stdio.h>
int main(int argc, char **argv) {
printf("Hello world!\n");
return 0;
}

tools/llvm-mctoll/test/smoke_test/lit.local.cfg

  • This file was added.
config.suffixes = ['.c']

tools/llvm-mctoll/test/smoke_test/simple-phi-test.c

  • This file was added.
// RUN: clang -o %t.so %S/Inputs/simple-phi.c -shared -fPIC
// RUN: llvm-mctoll -d %t.so
// RUN: clang -o %t1 %s %t-dis.ll
// RUN: %t1 2>&1 | FileCheck %s
// CHECK: true or true = true
// CHECK-NEXT: true or false = true
// CHECK-NEXT: false or true = true
// CHECK-NEXT: false or false = false
#include <stdio.h>
typedef int bool;
#define true 1
#define false 0
extern bool orvalues(bool r, bool y);
int main() {
printf("true or true = %s\n", (orvalues(true, true) ? "true" : "false"));
printf("true or false = %s\n", (orvalues(true, false) ? "true" : "false"));
printf("false or true = %s\n", (orvalues(false, true) ? "true" : "false"));
printf("false or false = %s\n", (orvalues(false, false) ? "true" : "false"));
return 0;
}

tools/llvm-mctoll/test/smoke_test/strcmp-test.c

  • This file was added.
// RUN: clang -o %t.so %S/Inputs/strcmp.c -shared -fPIC
// RUN: llvm-mctoll -d %t.so
// RUN: clang -o %t1 %s %t-dis.ll
// RUN: %t1 2>&1 | FileCheck %s
// CHECK: Lesser
// CHECK-NEXT: Equal
// CHECK-NEXT: Greater
#include <stdio.h>
extern int libc_strcmp(const char *p1, const char *p2);
int main() {
const char s1[] = "This is a string with label AOne";
const char s2[] = "This is a string with label ATwo";
int val = libc_strcmp(s1, s2);
if (val > 0) {
printf("Greater\n");
} else if (val == 0) {
printf("Equal\n");
} else {
printf("Lesser\n");
}
val = libc_strcmp(s2, s2);
if (val > 0) {
printf("Greater\n");
} else if (val == 0) {
printf("Equal\n");
} else {
printf("Lesser\n");
}
val = libc_strcmp(s2, s1);
if (val > 0) {
printf("Greater\n");
} else if (val == 0) {
printf("Equal\n");
} else {
printf("Lesser\n");
}
return 0;
}

tools/llvm-mctoll/test/smoke_test/test-1-test.c

  • This file was added.
// RUN: clang -o %t.so %S/Inputs/test-1.c -shared -fPIC
// RUN: llvm-mctoll -d %t.so
// RUN: clang -o %t1 %s %t-dis.ll
// RUN: %t1 2>&1 | FileCheck %s
// CHECK: test_1_func result 5
#include <stdio.h>
extern long test_1_func(int a, long b);
int main() {
printf("test_1_func result %ld\n", test_1_func(2, 3));
return 0;
}

tools/llvm-mctoll/test/smoke_test/test-2-test.c

  • This file was added.
// RUN: clang -o %t.so %S/Inputs/test-2.c -shared -fPIC
// RUN: llvm-mctoll -d %t.so
// RUN: clang -o %t1 %s %t-dis.ll
// RUN: %t1 2>&1 | FileCheck %s
// CHECK: test_2_func result 7
#include <stdio.h>
extern long test_2_func(int a, long b);
int main() {
printf("test_2_func result %ld\n", test_2_func(2, 3));
return 0;
}

tools/llvm-mctoll/test/smoke_test/test-3-test.c

  • This file was added.
// RUN: clang -o %t.so %S/Inputs/test-3.c -shared -fPIC
// RUN: llvm-mctoll -d %t.so
// RUN: clang -o %t1 %s %t-dis.ll
// RUN: %t1 2>&1 | FileCheck %s
// CHECK: test_3_func result 66
#include <stdio.h>
extern int test_3_func(int a, int b);
int main() {
printf("test_3_func result %d\n", test_3_func(234, 300));
return 0;
}

tools/llvm-mctoll/test/smoke_test/variadic-call-test.c

  • This file was added.
// RUN: clang -o %t %s
// RUN: llvm-mctoll -d %t
// RUN: clang -o %t1 %t-dis.ll
// RUN: %t1 2>&1 | FileCheck %s
// CHECK: Hello, World!
// CHECK: Hello again, World!
// CHECK: Sum = 6912
// CHECK: Sum of 1234 and 5678 = 6912
#include <stdio.h>
int main() {
int a = 1234, b = 5678;
printf("Hello, World!\n");
printf("Hello again, World!\n");
printf("Sum = %d\n", a + b);
printf("Sum of %d and %d = %d\n", a, b, a + b);
}

tools/llvm-mctoll/test/unittests/ARM/FunctionPrototype/lit.local.cfg

  • This file was added.
config.suffixes = ['.c']

tools/llvm-mctoll/test/unittests/ARM/FunctionPrototype/six_args.c

  • This file was added.
// RUN: clang -target arm -mfloat-abi=soft -c -o %t.o %s
// RUN: llvm-mctoll -d -print-after-all %t.o 2>&1 | FileCheck %s
// CHECK: ARMFunctionPrototype start
// CHECK: i32 @func(i32, i32, i32, i32, i32, i32)
// CHECK: ARMFunctionPrototype end
long func(int a, long b, int c, long d, int e, long f) {
return a + b + c + d + e + f;
}

tools/llvm-mctoll/test/unittests/ARM/PrologEpilog/lit.local.cfg

  • This file was added.
config.suffixes = ['.s']

tools/llvm-mctoll/test/unittests/ARM/PrologEpilog/push_pop.s

  • This file was added.
# RUN: clang -target arm -mfloat-abi=soft -c -o %t.o %s
# RUN: llvm-mctoll -d -print-after-all %t.o 2>&1 | FileCheck %s
# CHECK: ARMEliminatePrologEpilog start
# CHECK: Frame Objects:
# CHECK-NOT: $sp = STMDB_UPD %SP
# CHECK-NOT: $sp = SUBri %SP
# CHECK-NOT: $r11 = ADDri $sp
# CHECK-NOT: $sp = LDMIA_UPD %SP
# CHECK: ARMEliminatePrologEpilog end
# test push pop
.global test1
.type test1, %function
test1:
push {r11,lr}
add r11, sp, #4
sub sp, sp, #16
mov r0, #1
mov r1, #2
sub sp, r11, #4
pop {r11, pc}
.size test1, .-test1

tools/llvm-mctoll/test/unittests/ARM/PrologEpilog/push_pop_branch.s

  • This file was added.
# RUN: clang -target arm -mfloat-abi=soft -c -o %t.o %s
# RUN: llvm-mctoll -d -print-after-all %t.o 2>&1 | FileCheck %s
# CHECK: ARMEliminatePrologEpilog start
# CHECK: Frame Objects:
# CHECK-NOT: $sp = STMDB_UPD %SP
# CHECK-NOT: $sp = ADDri $r11
# CHECK-NOT: $r11, $sp = LDR_POST_IMM $sp
# CHECK: ARMEliminatePrologEpilog end
# test push pop and branch
.global test2
.type test2, %function
test2:
push {r11,lr}
add r11, sp, #4
sub sp, sp, #16
mov r0, #1
mov r1, #2
bl max
sub sp, r11, #4
pop {r11, pc}
max:
push {r11}
add r11, sp, #0
sub sp, sp, #12
cmp r0, r1
movlt r0, r1
add sp, r11, #0
pop {r11}
bx lr
.size test2, .-test2

tools/llvm-mctoll/test/unittests/ARM/PrologEpilog/stm_ldm_no_frame.s

  • This file was added.
# RUN: clang -target arm -mfloat-abi=soft -c -o %t.o %s
# RUN: llvm-mctoll -d -print-after-all %t.o 2>&1 | FileCheck %s
# CHECK: ARMEliminatePrologEpilog start
# CHECK: Frame Objects:
# CHECK-NOT: $sp = STMDB_UPD %SP
# CHECK-NOT: LDMIA $sp, 14, $noreg,
# CHECK: ARMEliminatePrologEpilog end
# test stm ldm with no frame
.global test3
.type test3, %function
test3:
stmdb r13!, {r0-r3}
stmdb r13!, {r4-r12,r13,r14}
mov r3, #0
mov r0,r3
ldmia r13, {r4-r11, r13, r15}
.size test3, .-test3

tools/llvm-mctoll/test/unittests/ARM/PrologEpilog/stm_ldm_with_frame.s

  • This file was added.
# RUN: clang -target arm -mfloat-abi=soft -c -o %t.o %s
# RUN: llvm-mctoll -d -print-after-all %t.o 2>&1 | FileCheck %s
# CHECK: ARMEliminatePrologEpilog start
# CHECK: Frame Objects:
# CHECK-NOT: $r12 = MOVr $sp
# CHECK-NOT: $sp = STMDB_UPD $sp, 14
# CHECK-NOT: $r11 = SUBri $r12, 16, 14,
# CHECK-NOT: LDMDB $sp, 14,
# CHECK: ARMEliminatePrologEpilog end
# test stm ldm with frame
.global test4
.type test4, %function
test4:
mov r12, r13
stmdb r13!, {r0-r3}
stmdb r13!, {r4-r12, r14}
sub r11, r12, #16
mov r3, #0
mov r0,r3
ldmdb r13, {r4-r11, r13, r15}
.size test4, .-test4

tools/llvm-mctoll/test/unittests/ARM/PrologEpilog/str_ldr.s

  • This file was added.
# RUN: clang -target arm -mfloat-abi=soft -c -o %t.o %s
# RUN: llvm-mctoll -d -print-after-all %t.o 2>&1 | FileCheck %s
# CHECK: ARMEliminatePrologEpilog start
# CHECK: Frame Objects:
# CHECK-NOT: early-clobber $sp = STR_PRE_IMM $r11
# CHECK-NOT: $r11 = ADDri $sp, 0, 14,
# CHECK-NOT: $sp = SUBri $r11, 0, 14,
# CHECK-NOT: $r11, $sp = LDR_POST_IMM $sp,
# CHECK: ARMEliminatePrologEpilog end
# test str ldr
.text
.align 4
.code 32
.global test
.type test, %function
test:
str fp, [sp, #-4]!
add fp, sp, #0
mov r3, #0
mov r0,r3
sub sp, fp, #0
ldr fp, [sp], #4
.size test, .-test
.global test
.type test, %function

tools/llvm-mctoll/test/unittests/ARMInstrs/add-dis.ll

  • This file was added.
; ModuleID = 'add.o'
source_filename = "add.o"
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
define i32 @funcAddReg(i32 %arg.1, i32 %arg.2) {
%stack.3 = alloca i32
%stack.4 = alloca i32
%stack.5 = alloca i32
%stack.6 = alloca i32
%1 = add i32 %arg.2, 0
%2 = add i32 %arg.1, 0
store i32 %1, i32* %stack.3
store i32 %2, i32* %stack.4
%3 = load i32, i32* %stack.3
%4 = load i32, i32* %stack.4
%5 = add i32 %3, %4
store i32 %1, i32* %stack.5
store i32 %2, i32* %stack.6
ret i32 %5
}

tools/llvm-mctoll/test/unittests/ARMInstrs/add.s

  • This file was added.
.text
.align 4
.code 32
.global funcAddReg
.type funcAddReg, %function
funcAddReg:
sub sp, sp, #16
mov r2, r1
mov r3, r0
str r0, [sp, #12]
str r1, [sp, #8]
ldr r0, [sp, #12]
ldr r1, [sp, #8]
add r0, r0, r1
str r2, [sp, #4]
str r3, [sp]
add sp, sp, #16
bx lr
.size funcAddReg, .-funcAddReg

tools/llvm-mctoll/test/unittests/ARMInstrs/harness.c

  • This file was added.
#include <stdio.h>
extern int funcAddReg(int a, int b);
int main() {
printf("funcAddReg result is %d\n", funcAddReg(2, 3));
return 0;
}

tools/llvm-mctoll/test/unittests/ARMInstrs/inst-test.py

  • This file was added.
#!/usr/bin/env python
import os
import sys
import argparse
import subprocess
import filecmp
import difflib
import shutil
from distutils.spawn import find_executable
test_src_harness = 'harness.c'
test_dir = os.path.dirname(os.path.realpath(__file__))
test_sources = []
for file in os.listdir(test_dir):
if os.path.splitext(file)[1] == '.s':
test_sources.append(file)
clang_bin='clang'
llc_bin='llc'
clang_executable=None
llc_executable=None
generated_files=[]
generated_results=[]
def get_args():
'''Get arguments'''
# Assign description to the help doc
parser = argparse.ArgumentParser(
description='Get script arguments')
# Add arguments
parser.add_argument(
'-b', '--binary', type=str, help='test specified llvm-mctoll binary', required=True)
parser.add_argument(
'-l', '--llvm', type=str, help='directory with LLVM binaries', default=None)
# Default is to not clean out artifacts created during the smoke-test
# So, if -c is specified, the action is to set it to true
parser.add_argument(
'-c', '--clean', help='Clean all artifacts', action='store_true')
# Array for all arguments passed to script
args = parser.parse_args()
# Assign args to variables
test_bin = args.binary
llvm_dir = args.llvm
clean = args.clean
print clean
# Return all variable values
return test_bin, llvm_dir, clean, parser
def main(argv):
mctoll_binary, llvm_binary_dir, clean_after_run, argparser = get_args()
# Check sanity llvm_binary_dir, if specified
if llvm_binary_dir is None:
# Make sure clang is available
output = find_executable(clang_bin)
if output:
print "Using clang in command-line path"
else:
print "clang not found in path. Specify using -l option"
argparser.print_help()
sys.exit(-1)
# Make sure clang is available
output = find_executable(llc_bin)
if output:
print "Using llc in command-line path"
else:
print "llc not found in path. Specify using -l option"
argparser.print_help()
sys.exit(-1)
else:
if os.path.isdir(llvm_binary_dir):
# Make sure clang is available
clang_executable = os.path.join(llvm_binary_dir.rstrip(os.sep), clang_bin)
if os.path.exists(os.path.join(clang_executable)):
print "Using clang : " + clang_executable
else:
print "No clang found in " + llvm_binary_dir
sys.exit(2)
# Make sure llc is available
llc_executable = os.path.join(llvm_binary_dir.rstrip(os.sep), llc_bin)
if os.path.exists(os.path.join(llc_executable)):
print "Using llc : " + llc_executable
else:
print "No llc found in " + llvm_binary_dir
sys.exit(2)
else:
print "Directory " + llvm_binary_dir + " does not exist"
sys.exit(2)
# Compile assemble file to object file
print "Looking in test directory " + test_dir
for test_src_name in test_sources :
test_src_full_path = os.path.join(test_dir.rstrip(os.sep), test_src_name)
print "Compiling " + test_src_full_path
subprocess.call([clang_executable, '-target', 'arm', '-c', test_src_full_path])
# Add the .o to generated_files
generated_files.append(os.path.splitext(test_src_name)[0]+'.o')
# Compile harness.c to ARM object file
harness_src_full_path = os.path.join(test_dir.rstrip(os.sep), test_src_harness)
print "Compiling ARM " + harness_src_full_path
subprocess.call([clang_executable, '-target', 'arm','-c', harness_src_full_path])
os.rename(os.path.splitext(test_src_harness)[0]+'.o', os.path.splitext(test_src_harness)[0]+'_arm.o')
# Add the .o to generated_files
generated_files.append(os.path.splitext(test_src_harness)[0]+'_arm.o')
# Link ARM object files with harness_arm.o to generate ARM executable file:
base_executable = os.path.splitext(test_src_harness)[0]
test_obj_list=[base_executable+'_arm.o']
for test_src_name in test_sources :
test_obj_list.append(os.path.splitext(test_src_name)[0]+'.o')
print "Linking ",
print test_obj_list
subprocess.call([clang_executable,"--target=arm-linux-gnueabi", "-static", "-o", base_executable] + test_obj_list)
# Add the base executable to generated_files
generated_results.append(base_executable)
# Raise test objects to generate .ll files
for test_src_name in test_sources :
test_name = os.path.splitext(test_src_name)[0]
test_obj = test_name +'.o'
raised_test_ll = test_name+"-dis.ll"
#ll_output = open(raised_test_ll, "w")
#Run mctoll on test-name.o to result in test-name-dis.ll
#subprocess.call([mctoll_binary, '-d', test_obj], stdout=ll_output, stderr=ll_output)
#Close file
#ll_output.close()
#Add the ll file to generated_files
#generated_files.append(raised_test_ll)
# Compile the ll files resulting from raising
print "Raising " + raised_test_ll
# Running llc -c test-name-dis.s
subprocess.call([llc_executable, raised_test_ll])
# Add the .s file to generated_files
generated_files.append(test_name+'-dis.s')
# Assemble the resulting .s to X86 object files using clang
# Running clang -c test-name-dis.s
subprocess.call([clang_executable, '-c', os.path.splitext(raised_test_ll)[0]+'.s'])
# Add the .o file to generated_files
generated_files.append(test_name+'-dis.o')
# Compile harness.c to harness_x86.o
print "Compiling X86 " + harness_src_full_path
subprocess.call([clang_executable,'-c', harness_src_full_path])
os.rename(os.path.splitext(test_src_harness)[0]+'.o', os.path.splitext(test_src_harness)[0]+'_x86.o')
# Add the .o to generated_files
generated_files.append(os.path.splitext(test_src_harness)[0]+'_x86.o')
# Link harness_x86.o with X86 object files to generate harness-dis
base_executable_dis = os.path.splitext(test_src_harness)[0]+'-dis'
test_obj_list_dis=[base_executable+'_x86.o']
for test_src_name in test_sources :
test_obj_list_dis.append(os.path.splitext(test_src_name)[0]+'-dis.o')
print "Linking ",
print test_obj_list_dis
subprocess.call([clang_executable, "-o", base_executable_dis] + test_obj_list_dis)
# Add the generated executable file to generated_files
generated_results.append(base_executable_dis)
# Now compare the execution of harness and harness-dis
gold_executable = './'+os.path.splitext(test_src_harness)[0]
raised_executable = gold_executable+'-dis'
gold_out_file_name = "gold_output"
gold_output = open(gold_out_file_name, "w")
print "Running " + gold_executable
subprocess.call(['qemu-arm', gold_executable], stdout=gold_output)
# Close file
gold_output.close()
# Add the generated output file
generated_results.append(gold_out_file_name)
raised_out_file_name = "raised_output"
raised_output = open(raised_out_file_name, "w")
print "Running " + raised_executable
subprocess.call([raised_executable], stdout=raised_output)
# Close file
raised_output.close()
# Add the generated output file
generated_results.append(raised_out_file_name)
# Compare gold output with raised execution output
diff_file = "diff"
if filecmp.cmp(gold_out_file_name, raised_out_file_name) :
print "Tests PASSED"
else :
print "Tests FAILED"
a = open('gold_output').readlines()
b = open('raised_output').readlines()
diff_result = open(diff_file, 'w+')
stdout = diff_result
diff = difflib.ndiff(a, b)
stdout.writelines(diff)
diff_result.close()
generated_results.append(diff_file)
diff_result = open(diff_file, 'r+')
for line in diff_result:
if line[0]=='-':
print line.split(' ')[1]+' Failed!'
# Move the generated files to corresponding folder
if os.path.exists("imm_files"):
shutil.rmtree("imm_files")
if os.path.exists("results"):
shutil.rmtree("results")
os.mkdir("imm_files")
os.mkdir("results")
for f in generated_files:
shutil.move(f, "imm_files")
for r in generated_results:
shutil.move(r, "results")
if clean_after_run:
print "Deleting all created artifacts ..."
shutil.rmtree("imm_files")
shutil.rmtree("results")
if __name__ == "__main__":
main(sys.argv[1:])