[llvm-mca][RFC] Adding binary support to llvm-mca.

[mattd]

Summary

Introduction

Currently llvm-mca only accepts assembly code as input. We would like to
extend llvm-mca to support object files, allowing users to analyze the
performance of binaries. The proposed changes optionally introduce an object
file section, but this can be stripped-out if desired.

For the llvm-mca binary support feature to be useful, a user needs to tell
llvm-mca which portions of their code they would like analyzed. Currently,
this is accomplished via assembly comments. However, assembly comments are not
preserved in object files, and this has encouraged this RFC. For the proposed
binary support, we need to introduce changes to clang and llvm to allow the
user's object code to be recognized by llvm-mca:

1. We need a way for a user to identify a region/block of code they want analyzed by llvm-mca.

2. We need the information defining the user's region of code to be maintained in the object file so that llvm-mca can analyze the desired region(s) from the binary object file.

We define a "code region" as a subset of a user's program that is to be
analyzed via llvm-mca. The sequence of instructions to be analyzed is
represented as a pair: <start, end> where the 'start' marks the beginning of
the user's source code and 'end' terminates the sequence. The instructions
between 'start' and 'end' form the region that can be analyzed by llvm-mca at a
later time.

Example

Before we go into the details of this proposed change, let's first look at a
simple example:

// example.c -- Analyze a dot-product expression.
double test(double x, double y) {

double result = 0.0;
__mca_code_region_start(42);
result += x * y;
__mca_code_region_end();
return result;

}

In the example above, we have identified a code region, in this case a single
dot-product expression. For the sake of brevity and simplicity, we've chosen
a very simple example, but in reality a more complicated example could use
multiple expressions. We have also denoted this region as number 42. That
identifier is only for the user, and simplifies reading an llvm-mca analysis
report later.

When this code is compiled, the region markers (the mca_code_region markers)
are transformed into assembly labels. While the markers are presented as
function calls, in reality they are no-ops.

test:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -8(%rbp)
movsd %xmm1, -16(%rbp)
.Lmca_code_region_start_0: # LLVM-MCA-START ID: 42
xorps %xmm0, %xmm0
movsd %xmm0, -24(%rbp)
movsd -8(%rbp), %xmm0
mulsd -16(%rbp), %xmm0
addsd -24(%rbp), %xmm0
movsd %xmm0, -24(%rbp)
.Lmca_code_region_end_0: # LLVM-MCA-END ID: 42
movsd -24(%rbp), %xmm0
popq %rbp
retq
.section .mca_code_regions,"",@progbits
.quad 42
.quad .Lmca_code_region_start_0
.quad .Lmca_code_region_end_0-.Lmca_code_region_start_0

The assembly has been trimmed to show the portions relevant to this RFC.
Notice the labels enclose the user's defined region, and that they preserve the
user's arbitrary region identifier, the ever-so-important region 42.

In the object file section .mca_code_regions, we have noted the user's region
identifier (.quad 42), start address, and region size. A more complicated
example can have multiple regions defined within a single .mca_code_regions
section. This section can be read by llvm-mca, allowing llvm-mca to take
object files as input instead of assembly source.

Details

We need a way for a user to identify a region/block of code they want analyzed
by llvm-mca. We solve this problem by introducing two intrinsics that a user can
specify, for identifying regions of code for analysis.

The two intrinsics are: llvm.mca.code.regions.start and
llvm.mca.code.regions.end. A user can identify a code region by inserting the
mca_code_region_start and mca_code_region_end markers. These are simply
clang builtins and are transformed into the aforementioned intrinsics during
compilation. The code between the intrinsics are what we call "code regions"
and are to be easily identifiable by llvm-mca; any code between a start/end
pair can be analyzed by llvm-mca at a later time. A user can define multiple
non-overlapping code regions within their program.

The llvm.mca.code.region.start intrinsic takes an integer constant as its only
argument. This argument is implemented as a metadata i32, and is only used
when generating llvm-mca reports. This value allows a user to more easily
identify a specific code region. llvm.mca.code.region.end takes no arguments.
Since we disallow nesting of regions, the first 'end' intrinsic lexically
following a 'start' intrinsic represents the end of that code region.

Now that we have a solution for identifying regions for analysis, we now need a
way for preserving that information to be read at a later time. To accomplish
this we propose adding a new section (.mca_code_regions) to the object file
generated by llvm. During code generation, the start/end intrinsics described
above will be transformed into start/end labels in assembly. When llvm
generates the object file from the user's code, these start/end labels form a
pair of values identifying the start of the user's code region, and size. The
size represents the number of bytes between the start and end address of the
labels. Note that the labels are emitted during assembly printing. We hope
that these labels have no influence on code generation or basic-block
placement. However, the target assembler strategy for handling labels is
outside of our control.

This proposed change affects the size of a binary, but only if the user calls
the start/end builtins mentioned above. The additional size of the
.mca_code_regions section, which we imagine to be very small (to the order of a
few bytes), can trivially be stripped by tools like 'strip' or 'objcopy'.

Implementation Status

We currently have the proposed changes implemented at the url posted below.
This initial patch only targets ELF object files, and does not handle
relocatable addresses. Since the start of a code region is represented as an
assembly label, and referenced in the .mca_code_regions section, that address
is relocatable. That value can be represented as section-relative relocatable
symbol (.text + addend), but we are not handling that case yet. Instead, the
proposed changes only handle linked/executable object files.

The change is presented as a monolithic patch; however, when the time comes
it will be split into three patches:

1. The introduction of the builtins to clang.
2. The llvm portion (the added intrinsics).
3. The llvm-mca portion.

This RFC was proposed to the wider llvm community here:
https://lists.llvm.org/pipermail/llvm-dev/2018-November/127784.html

[mattd]

• Rebased this patch.
• Added an additional IRVerifier check to generate a compiler error if a llvm-mca code region belongs to more than one basic-block (this was discussed in the llvm-dev mailing list thread).

[mattd]

test/CodeGen/builtins-mca.c

2

I'll fix the file mode when I generate the patch set for these changes.

[mattd]

Ping

Just pinging this patch and RFC to see if anyone else, aside from Andrea, has any feedback. The discussion on the RFC is here:
https://lists.llvm.org/pipermail/llvm-dev/2018-December/128218.html

[mattd]

• Following some discussion of the RFC on the mailing list, this patch makes a few improvements:
• Object files and executables are supported. This is accomplished by scanning the symbol table for mca_code_region_start and mca_code_region_end symbols.
• This solution does not rely on target specific relocations.
• Regions cannot be nested, so a start of region label/symbol must be followed by an end (this has always been the case).
• Symbol names are encoded with the user's defined region number." That number is just for cosmetic purposes and is only helpful for the user, llvm-mca can make use of that number to annotate its analysis reports.

[mattd]

In D54603#1333965, @mattd wrote:

• Following some discussion of the RFC on the mailing list, this patch makes a few improvements:
• Object files and executables are supported. This is accomplished by scanning the symbol table for mca_code_region_start and mca_code_region_end symbols.
• This solution does not rely on target specific relocations.
• Regions cannot be nested, so a start of region label/symbol must be followed by an end (this has always been the case).
• Symbol names are encoded with the user's defined region number." That number is just for cosmetic purposes and is only helpful for the user, llvm-mca can make use of that number to annotate its analysis reports.

I forgot to mention, this also removes the need for the .mca_code_regions object file section. All of the parsing and code-region identification is performed via symbol table.

[mattd]

• Corrected some comments and removed unnecessary code, as a result of the last two patches.
• Rebased

[mattd]

• Removed the check in IR/Verifier that rejected programs if llvm-mca code regions span multiple blocks.

In short, we let llvm-mca handle multiple blocks as it always has. To be fair here, llvm-mca doesn't handle branch instructions, but a user can currently place LLVM-MCA assembly comments such that the instructions cross multiple blocks.

[mattd]

• Renamed the assembly comment that gets added to assembly files when using the llvm.mca.code.region.start intrinsic.

[mattd]

• Update the symbol name parsing for the llvm-mca region markers.

This update allows llvm-mca to sort code regions based on both the start address of the region and the compiler-generated sequence number.
The sequence number is useful when sorting regions that might begin/end at the same address. This can be helpful in cases where a region begins immediately after the previous one ends.

[mattd]

include/llvm/Target/Target.td

1192

I've set hasSideEffects to true, so that DeadMachineInstructionElim does not remove the llvm-mca code markers under optimization. However, it's certainly possible that optimizations will move code outside of the region.

[RKSimon]

Should the test/CodeGen/X86/*.ll tests be put in test/CodeGen/Generic/*.ll instead?

[mattd]

• Rebased against master
• Moved most of the added llvm-mca CodeGen/X86 tests to CodeGen/Generic.

[mattd]

Update the SelectionDAG handling of the mca_code_region_start and mca_code_region_end intrinsics.

The previous version of this patch just emitted the machine instructions when building the SelectionDAG. Now we are generating SDNodes which seems to give a better representation of the code blocks during inlining/optimization.

include/clang/Basic/Builtins.def

 BUILTIN(__xray_customevent, "vcC*z", "")
 BUILTIN(__xray_typedevent, "vzcC*z", "")
 
 // Win64-compatible va_list functions
 BUILTIN(__builtin_ms_va_start, "vc*&.", "nt")
 BUILTIN(__builtin_ms_va_end, "vc*&", "n")
 BUILTIN(__builtin_ms_va_copy, "vc*&c*&", "n")
 
+// Builtins for llvm-mca
+BUILTIN(__mca_code_region_start, "vIi", "")
+BUILTIN(__mca_code_region_end, "v", "")
+
 #undef BUILTIN
 #undef LIBBUILTIN
 #undef LANGBUILTIN

include/llvm/IR/Intrinsics.td

 def int_experimental_vector_reduce_fmin : Intrinsic<[llvm_anyfloat_ty],
                                                     [llvm_anyvector_ty],
                                                     [IntrNoMem]>;
 
 //===----- Intrinsics that are used to provide predicate information -----===//
 
 def int_ssa_copy : Intrinsic<[llvm_any_ty], [LLVMMatchType<0>],
                              [IntrNoMem, Returned<0>]>;
+
+
+//===---------------------- Tool Specific Intrinsics ----------------------===//
+//
+def int_mca_code_region_start : Intrinsic<[], [llvm_metadata_ty]>;
+def int_mca_code_region_end   : Intrinsic<[]>;
+
 //===----------------------------------------------------------------------===//
 // Target-specific intrinsics
 //===----------------------------------------------------------------------===//
 
 include "llvm/IR/IntrinsicsPowerPC.td"
 include "llvm/IR/IntrinsicsX86.td"
 include "llvm/IR/IntrinsicsARM.td"
 include "llvm/IR/IntrinsicsAArch64.td"

include/llvm/MC/MCContext.h

private:
 
     SpecificBumpPtrAllocator<MCSubtargetInfo> MCSubtargetAllocator;
 
     /// Do automatic reset in destructor
     bool AutoReset;
 
     bool HadError = false;
 
+    /// A counter for the number of MCACodeRegions we expect to generate.
+    /// This value is used to make the region names unique per module.
+    size_t MCACodeRegionCount = 0;
+
     MCSymbol *createSymbolImpl(const StringMapEntry<bool> *Name,
                                bool CanBeUnnamed);
     MCSymbol *createSymbol(StringRef Name, bool AlwaysAddSuffix,
                            bool IsTemporary);
 
     MCSymbol *getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal,
                                                 unsigned Instance);
 
const MCAsmMacro *lookupMacro(StringRef Name) {
       return (I == MacroMap.end()) ? nullptr : &I->getValue();
     }
 
     void defineMacro(StringRef Name, MCAsmMacro Macro) {
       MacroMap.insert(std::make_pair(Name, std::move(Macro)));
     }
 
     void undefineMacro(StringRef Name) { MacroMap.erase(Name); }
+
+    /// Returns the number of llvm-mca code regions.
+    size_t getMCACodeRegionCount() const { return MCACodeRegionCount; }
+
+    /// Add a marker to the container of llvm-mca code markers.
+    void incrementMCACodeRegionCount() { ++MCACodeRegionCount; }
   };
 
 } // end namespace llvm
 
 // operator new and delete aren't allowed inside namespaces.
 // The throw specifications are mandated by the standard.
 /// Placement new for using the MCContext's allocator.
 ///

include/llvm/Support/TargetOpcodes.def

 HANDLE_TARGET_OPCODE(G_FCEIL)
 
 /// Generic AddressSpaceCast.
 HANDLE_TARGET_OPCODE(G_ADDRSPACE_CAST)
 
 /// Generic block address
 HANDLE_TARGET_OPCODE(G_BLOCK_ADDR)
 
+/// llvm-mca code markers.
+HANDLE_TARGET_OPCODE(MCA_CODE_REGION_START)
+HANDLE_TARGET_OPCODE(MCA_CODE_REGION_END)
+
 // TODO: Add more generic opcodes as we move along.
 
 /// Marker for the end of the generic opcode.
 /// This is used to check if an opcode is in the range of the
 /// generic opcodes.
 HANDLE_TARGET_OPCODE_MARKER(PRE_ISEL_GENERIC_OPCODE_END, G_BLOCK_ADDR)
 
 /// BUILTIN_OP_END - This must be the last enum value in this list.
 /// The target-specific post-isel opcode values start here.
 HANDLE_TARGET_OPCODE_MARKER(GENERIC_OP_END, PRE_ISEL_GENERIC_OPCODE_END)

include/llvm/Target/Target.td

def FENTRY_CALL : StandardPseudoInstruction {
   let hasSideEffects = 1;
 }
 def ICALL_BRANCH_FUNNEL : StandardPseudoInstruction {
   let OutOperandList = (outs unknown:$dst);
   let InOperandList = (ins variable_ops);
   let AsmString = "";
   let hasSideEffects = 1;
 }
+def MCA_CODE_REGION_START : StandardPseudoInstruction {
+  let OutOperandList = (outs);
+  let InOperandList = (ins i32imm:$id);
+  let AsmString = "# LLVM-MCA-BEGIN";
+  let hasSideEffects = 1;
+}
+def MCA_CODE_REGION_END : StandardPseudoInstruction {
+  let OutOperandList = (outs);
+  let InOperandList = (ins);
+  let AsmString = "# LLVM-MCA-END";
+  let hasSideEffects = 1;
+}
 
 // Generic opcodes used in GlobalISel.
 include "llvm/Target/GenericOpcodes.td"
 
 //===----------------------------------------------------------------------===//
 // AsmParser - This class can be implemented by targets that wish to implement
 // .s file parsing.
 //

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
     assert(Op.isReg() && "KILL instruction must have only register operands");
     OS << ' ' << (Op.isDef() ? "def " : "killed ")
        << printReg(Op.getReg(), AP.MF->getSubtarget().getRegisterInfo());
   }
   AP.OutStreamer->AddComment(OS.str());
   AP.OutStreamer->AddBlankLine();
 }
 
+/// This routine annotates the assembly with a comment and inserts the unique
+/// llvm-mca code region start label.  'ID' represents the user's defined
+/// region number, the argument specified in llvm.mca.code.region.start().
+static MCSymbol *emitMCACodeRegionStart(const MachineInstr *StartMI,
+                                        uint64_t ID, AsmPrinter &AP) {
+  assert(StartMI->getOpcode() == TargetOpcode::MCA_CODE_REGION_START &&
+         "Invalid llvm-mca start code region instruction.");
+  AP.OutStreamer->AddComment("LLVM-MCA-BEGIN" + StringRef(" ID: ") +
+                             std::to_string(ID));
+  // The symbol name format: .mca_code_region_start.<ID>.<counter>
+  MCSymbol *Symbol = AP.OutContext.getOrCreateSymbol(
+      ".mca_code_region_start." + std::to_string(ID) + "." +
+      std::to_string(AP.OutContext.getMCACodeRegionCount()));
+  AP.OutStreamer->EmitLabel(Symbol);
+  return Symbol;
+}
+
+/// This routine annotates the assembly with a comment and creates a label to
+/// mark the end of a llvm-mca code region.
+static void emitMCACodeRegionEnd(const MachineInstr *EndMI, uint64_t ID,
+                                 const MCSymbol *StartSymbol, AsmPrinter &AP) {
+  assert(EndMI->getOpcode() == TargetOpcode::MCA_CODE_REGION_END &&
+         "Invalid llvm-mca 'end' code region instruction.");
+  // Ensure that we have a start symbol for this region.
+  assert(StartSymbol && "Found an 'end' llvm-mca code region marker without a "
+                        "preceding start marker.");
+  AP.OutStreamer->AddComment("LLVM-MCA-END" + StringRef(" ID: ") +
+                             std::to_string(ID));
+
+  // The symbol name format: .mca_code_region_end.<ID>.<counter>
+  MCSymbol *EndSymbol = AP.OutContext.getOrCreateSymbol(
+      ".mca_code_region_end." + std::to_string(ID) + "." +
+      std::to_string(AP.OutContext.getMCACodeRegionCount()));
+  AP.OutStreamer->EmitLabel(EndSymbol);
+  AP.OutContext.incrementMCACodeRegionCount();
+}
+
 /// emitDebugValueComment - This method handles the target-independent form
 /// of DBG_VALUE, returning true if it was able to do so.  A false return
 /// means the target will need to handle MI in EmitInstruction.
 static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) {
   // This code handles only the 4-operand target-independent form.
   if (MI->getNumOperands() != 4)
     return false;
 
if (!MLI) {
       OwnedMLI->getBase().analyze(MDT->getBase());
       MLI = OwnedMLI.get();
     }
   }
 
   // Print out code for the function.
   bool HasAnyRealCode = false;
   int NumInstsInFunction = 0;
+  uint64_t MCARegionID = 0;
+  const MCSymbol *MCARegionStartSym = nullptr;
   for (auto &MBB : *MF) {
     // Print a label for the basic block.
     EmitBasicBlockStart(MBB);
     for (auto &MI : MBB) {
       // Print the assembly for the instruction.
       if (!MI.isPosition() && !MI.isImplicitDef() && !MI.isKill() &&
           !MI.isDebugInstr()) {
         HasAnyRealCode = true;
for (auto &MI : MBB) {
         }
         break;
       case TargetOpcode::IMPLICIT_DEF:
         if (isVerbose()) emitImplicitDef(&MI);
         break;
       case TargetOpcode::KILL:
         if (isVerbose()) emitKill(&MI, *this);
         break;
+      case TargetOpcode::MCA_CODE_REGION_START: {
+        assert(!MCARegionStartSym && "Nested llvm-mca markers are not allowed");
+        // Get the user's defined region ID.
+        assert(MI.getOperand(0).isImm() &&
+               "Invalid operand for MCA_CODE_REGION_START.");
+        MCARegionID = MI.getOperand(0).getImm();
+        MCARegionStartSym = emitMCACodeRegionStart(&MI, MCARegionID, *this);
+        break;
+      }
+      case TargetOpcode::MCA_CODE_REGION_END: {
+        emitMCACodeRegionEnd(&MI, MCARegionID, MCARegionStartSym, *this);
+        MCARegionStartSym = nullptr;
+        break;
+      }
       default:
         EmitInstruction(&MI);
         break;
       }
 
       // If there is a post-instruction symbol, emit a label for it here.
       if (MCSymbol *S = MI.getPostInstrSymbol())
         OutStreamer->EmitLabel(S);
 
       if (ShouldPrintDebugScopes) {
         for (const HandlerInfo &HI : Handlers) {
           NamedRegionTimer T(HI.TimerName, HI.TimerDescription,
                              HI.TimerGroupName, HI.TimerGroupDescription,
                              TimePassesIsEnabled);
           HI.Handler->endInstruction();
         }
       }
     }
 
     EmitBasicBlockEnd(MBB);
   }
 
+  // Ensure that if MCA markers were used, that there are no
+  // dangling/unterminated regions.  MCARegionStartSym is set to nullptr when an
+  // end-region marker is discovered.
+  assert(!MCARegionStartSym &&
+         "Found an unterminated llvm-mca code region.");
+
   EmittedInsts += NumInstsInFunction;
   MachineOptimizationRemarkAnalysis R(DEBUG_TYPE, "InstructionCount",
                                       MF->getFunction().getSubprogram(),
                                       &MF->front());
   R << ore::NV("NumInstructions", NumInstsInFunction)
     << " instructions in function";
   ORE->emit(R);
 

lib/CodeGen/CGBuiltin.cpp

case Builtin::BI__builtin_ms_va_copy: {
     DestAddr = Address(Builder.CreateBitCast(DestAddr.getPointer(), BPP, "cp"),
                        DestAddr.getAlignment());
     SrcAddr = Address(Builder.CreateBitCast(SrcAddr.getPointer(), BPP, "ap"),
                       SrcAddr.getAlignment());
 
     Value *ArgPtr = Builder.CreateLoad(SrcAddr, "ap.val");
     return RValue::get(Builder.CreateStore(ArgPtr, DestAddr));
   }
+
+  case Builtin::BI__mca_code_region_start: {
+    // Get the user-defined identifier as a ConstantInt*, the frontend should
+    // guarantee that arg(0) is an ICE.
+    APSInt ID;
+    E->getArg(0)->isIntegerConstantExpr(ID, getContext());
+    ConstantInt *IDValue = llvm::ConstantInt::get(getLLVMContext(), ID);
+
+    // Create the call to llvm.mca.code.region.start(metadata).
+    Metadata *MD = llvm::ConstantAsMetadata::get(IDValue);
+    Function *F = CGM.getIntrinsic(Intrinsic::mca_code_region_start);
+    return RValue::get(Builder.CreateCall(
+        F, llvm::MetadataAsValue::get(getLLVMContext(), MD)));
+  }
+
+  case Builtin::BI__mca_code_region_end: {
+    Function *F = CGM.getIntrinsic(Intrinsic::mca_code_region_end);
+    return RValue::get(Builder.CreateCall(F));
+  }
   }
 
   // If this is an alias for a lib function (e.g. __builtin_sin), emit
   // the call using the normal call path, but using the unmangled
   // version of the function name.
   if (getContext().BuiltinInfo.isLibFunction(BuiltinID))
     return emitLibraryCall(*this, FD, E,
                            CGM.getBuiltinLibFunction(FD, BuiltinID));

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

case Intrinsic::icall_branch_funnel: {
     return nullptr;
   }
 
   case Intrinsic::wasm_landingpad_index:
     // Information this intrinsic contained has been transferred to
     // MachineFunction in SelectionDAGISel::PrepareEHLandingPad. We can safely
     // delete it now.
     return nullptr;
+
+  case Intrinsic::mca_code_region_start: {
+    MetadataAsValue *RegionMD = dyn_cast<MetadataAsValue>(I.getArgOperand(0));
+    Metadata *MD = RegionMD->getMetadata();
+    ConstantInt *ID = mdconst::extract_or_null<ConstantInt>(MD);
+    if (!ID) {
+      DAG.getContext()->emitError(
+          &I, "Expected constant integer argument to mca_code_region_start.");
+      return nullptr;
+    }
+    SDLoc DL = getCurSDLoc();
+    SDValue IDVal = DAG.getTargetConstant(ID->getLimitedValue(), sdl, MVT::i64);
+    SDValue Chain = getRoot();
+    SDValue N(DAG.getMachineNode(TargetOpcode::MCA_CODE_REGION_START, sdl,
+                                 MVT::Other, IDVal, Chain),
+              0);
+    DAG.setRoot(N);
+    setValue(&I, N);
+    return nullptr;
+  }
+
+  case Intrinsic::mca_code_region_end: {
+    SDValue N(DAG.getMachineNode(TargetOpcode::MCA_CODE_REGION_END, sdl,
+                                 MVT::Other, getRoot()),
+              0);
+    DAG.setRoot(N);
+    setValue(&I, N);
+    return nullptr;
+  }
   }
 }
 
 void SelectionDAGBuilder::visitConstrainedFPIntrinsic(
     const ConstrainedFPIntrinsic &FPI) {
   SDLoc sdl = getCurSDLoc();
   unsigned Opcode;
   switch (FPI.getIntrinsicID()) {

lib/IR/Verifier.cpp

class Verifier : public InstVisitor<Verifier>, VerifierSupport {
   // This map is used to avoid visiting uses twice. We can arrive at a user
   // twice, if they have multiple operands. In particular for very large
   // constant expressions, we can arrive at a particular user many times.
   SmallPtrSet<const Value *, 32> GlobalValueVisited;
 
   // Keeps track of duplicate function argument debug info.
   SmallVector<const DILocalVariable *, 16> DebugFnArgs;
 
+  // Keeps track of the start/end mca code region intrinsics to ensure
+  // they do not nest.
+  SmallVector<const IntrinsicInst *, 8> MCACodeRegions;
+
   TBAAVerifier TBAAVerifyHelper;
 
   void checkAtomicMemAccessSize(Type *Ty, const Instruction *I);
 
 public:
   explicit Verifier(raw_ostream *OS, bool ShouldTreatBrokenDebugInfoAsError,
                     const Module &M)
       : VerifierSupport(OS, M), LandingPadResultTy(nullptr),
for (const BasicBlock &BB : F) {
       }
       return false;
     }
 
     Broken = false;
     // FIXME: We strip const here because the inst visitor strips const.
     visit(const_cast<Function &>(F));
     verifySiblingFuncletUnwinds();
+    verifyMCACodeRegions();
     InstsInThisBlock.clear();
     DebugFnArgs.clear();
     LandingPadResultTy = nullptr;
     SawFrameEscape = false;
     SiblingFuncletInfo.clear();
 
     return !Broken;
   }
#include "llvm/IR/Metadata.def"
   void verifyCompileUnits();
 
   /// Module-level verification that all @llvm.experimental.deoptimize
   /// declarations share the same calling convention.
   void verifyDeoptimizeCallingConvs();
 
   /// Verify all-or-nothing property of DIFile source attribute within a CU.
   void verifySourceDebugInfo(const DICompileUnit &U, const DIFile &F);
+
+  /// Verify that the MCA code regions collected are well-formed.
+  void verifyMCACodeRegions();
 };
 
 } // end anonymous namespace
 
 /// We know that cond should be true, if not print an error message.
 #define Assert(C, ...) \
   do { if (!(C)) { CheckFailed(__VA_ARGS__); return; } } while (false)
 
case Intrinsic::smul_fix: {
     auto *Op3 = dyn_cast<ConstantInt>(Call.getArgOperand(2));
     Assert(Op3, "third argument of smul_fix must be a constant integer");
     Assert(Op3->getType()->getBitWidth() <= 32,
            "third argument of smul_fix must fit within 32 bits");
     Assert(Op3->getZExtValue() < Op1->getType()->getScalarSizeInBits(),
            "the scale of smul_fix must be less than the width of the operands");
     break;
   }
+  case Intrinsic::mca_code_region_start: {
+    if (!MCACodeRegions.empty() &&
+        MCACodeRegions.back()->getIntrinsicID() ==
+            Intrinsic::mca_code_region_start)
+      report_fatal_error("Nested llvm-mca code region markers are not allowed.",
+                         false);
+    MCACodeRegions.push_back(cast<IntrinsicInst>(&Call));
+    break;
+  }
+  case Intrinsic::mca_code_region_end: {
+    if (MCACodeRegions.empty() ||
+        MCACodeRegions.back()->getIntrinsicID() ==
+            Intrinsic::mca_code_region_end)
+      report_fatal_error("Found an 'end' llvm-mca code region marker without a "
+                         "preceding start marker.",
+                         false);
+    const auto I = cast<IntrinsicInst>(&Call);
+    MCACodeRegions.push_back(I);
+    break;
+  }
   };
 }
 
 /// Carefully grab the subprogram from a local scope.
 ///
 /// This carefully grabs the subprogram from a local scope, avoiding the
 /// built-in assertions that would typically fire.
 static DISubprogram *getSubprogram(Metadata *LocalScope) {

 void Verifier::verifySourceDebugInfo(const DICompileUnit &U, const DIFile &F) {
   bool HasSource = F.getSource().hasValue();
   if (!HasSourceDebugInfo.count(&U))
     HasSourceDebugInfo[&U] = HasSource;
   AssertDI(HasSource == HasSourceDebugInfo[&U],
            "inconsistent use of embedded source");
 }
 
+void Verifier::verifyMCACodeRegions() {
+  if (!MCACodeRegions.empty()) {
+    // We have already verified the order of the start/end markers via
+    // visitIntrinsicCallSite.  Verify that the last marker is an end marker.
+    if (MCACodeRegions.back()->getIntrinsicID() !=
+        Intrinsic::mca_code_region_end)
+      report_fatal_error("Found an unterminated llvm-mca code region.");
+    MCACodeRegions.clear();
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //  Implement the public interfaces to this file...
 //===----------------------------------------------------------------------===//
 
 bool llvm::verifyFunction(const Function &f, raw_ostream *OS) {
   Function &F = const_cast<Function &>(f);
 
   // Don't use a raw_null_ostream.  Printing IR is expensive.

test/CodeGen/Generic/mca-code-region-error-nest.ll

+; RUN: not llc -O0 %s 2>&1 | FileCheck %s
+
+; Test that nests are rejected.
+; CHECK: Nested llvm-mca code region markers are not allowed.
+define dso_local void @test() {
+  call void @llvm.mca.code.region.start(metadata i32 1)
+  call void @doStuff()
+  call void @llvm.mca.code.region.end()
+
+  call void @llvm.mca.code.region.start(metadata i32 2)
+  call void @llvm.mca.code.region.start(metadata i32 3)
+  call void @doStuff()
+  call void @llvm.mca.code.region.end()
+  ret void
+}
+
+declare dso_local void @doStuff()
+declare void @llvm.mca.code.region.start(metadata)
+declare void @llvm.mca.code.region.end()

test/CodeGen/Generic/mca-code-region-error-no-start.ll

+; RUN: not llc -O0 < %s 2>&1 | FileCheck %s
+
+; Test no start intrinsic.
+; CHECK: Found an 'end' llvm-mca code region marker without a preceding start marker.
+define dso_local void @test() {
+  call void @doStuff()
+  call void @llvm.mca.code.region.end()
+  ret void
+}
+
+declare dso_local void @doStuff()
+declare void @llvm.mca.code.region.start(metadata)
+declare void @llvm.mca.code.region.end()

test/CodeGen/Generic/mca-code-region-error-unterminated.ll

+; RUN: not llc -O0 %s 2>&1 | FileCheck %s
+
+; Test no end intrinsic.
+; CHECK: Found an unterminated llvm-mca code region.
+define dso_local void @test() {
+  call void @llvm.mca.code.region.start(metadata i32 1)
+  call void @doStuff()
+  ret void
+}
+
+declare dso_local void @doStuff()
+declare void @llvm.mca.code.region.start(metadata)
+declare void @llvm.mca.code.region.end()

test/CodeGen/X86/mca-code-regions.ll

+; RUN: llc -O0 -mtriple=x86_64-- < %s | FileCheck %s
+
+define dso_local void @test() {
+  call void @llvm.mca.code.region.start(metadata i32 1)
+  call void @doStuff(i32 1)
+  call void @llvm.mca.code.region.end()
+
+  call void @llvm.mca.code.region.start(metadata i32 2)
+  call void @doStuff(i32 2)
+  call void @llvm.mca.code.region.end()
+
+  call void @llvm.mca.code.region.start(metadata i32 3)
+  call void @doStuff(i32 3)
+  call void @llvm.mca.code.region.end()
+
+  call void @llvm.mca.code.region.start(metadata i32 4)
+  call void @doStuff(i32 4)
+  call void @llvm.mca.code.region.end()
+
+  ; Duplicate user-defined region identifiers (number 4 here) are allowed.
+  call void @llvm.mca.code.region.start(metadata i32 4)
+  call void @doStuff(i32 4)
+  call void @llvm.mca.code.region.end()
+
+  call void @llvm.mca.code.region.start(metadata i32 5)
+  call void @doStuff(i32 5)
+  call void @llvm.mca.code.region.end()
+
+  ret void
+}
+
+; CHECK-LABEL: .mca_code_region_start.1.0:
+; CHECK-NEXT:  movl $1, %edi
+; CHECK-NEXT:  callq doStuff
+; CHECK-LABEL: .mca_code_region_end.1.0:
+; CHECK-LABEL: .mca_code_region_start.2.1:
+; CHECK-NEXT:  movl $2, %edi
+; CHECK-NEXT:  callq doStuff
+; CHECK-LABEL: .mca_code_region_end.2.1:
+; CHECK-LABEL: .mca_code_region_start.3.2:
+; CHECK-NEXT:  movl $3, %edi
+; CHECK-NEXT:  callq doStuff
+; CHECK-LABEL: .mca_code_region_end.3.2:
+; CHECK-LABEL: .mca_code_region_start.4.3:
+; CHECK-NEXT:  movl $4, %edi
+; CHECK-NEXT:  callq doStuff
+; CHECK-LABEL: .mca_code_region_end.4.3:
+; CHECK-LABEL: .mca_code_region_start.4.4:
+; CHECK-NEXT:  movl $4, %edi
+; CHECK-NEXT:  callq doStuff
+; CHECK-LABEL: .mca_code_region_end.4.4:
+; CHECK-LABEL: .mca_code_region_start.5.5:
+; CHECK-NEXT:  movl $5, %edi
+; CHECK-NEXT:  callq doStuff
+; CHECK-LABEL: .mca_code_region_end.5.5:
+
+declare dso_local void @doStuff(i32)
+declare void @llvm.mca.code.region.start(metadata)
+declare void @llvm.mca.code.region.end()

test/CodeGen/builtins-mca.c

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O0 -o - %s | FileCheck %s
+extern void sendUniverse(void);
+
+void addUniverse(){
+  __mca_code_region_start(42);
+// CHECK: call void @llvm.mca.code.region.start(metadata i32 42)
+// CHECK: call void @sendUniverse()
+  sendUniverse();
+// CHECK: call void @llvm.mca.code.region.end()
+  __mca_code_region_end();
+}
+
+// CHECK: declare void @llvm.mca.code.region.start(metadata)
+// CHECK: declare void @llvm.mca.code.region.end()

test/tools/llvm-mca/Binary/multiple-code-regions-exec.test

+# Note that the original source can be extracted from multiple-regions.elf via
+# objcopy --dump-section .test_source=test.c ./multiple-regions-exec.elf
+
+# RUN: llvm-mca %p/Inputs/multiple-regions-exec.elf -dump-binary-regions | FileCheck %s
+
+# CHECK: .mca_code_regions:
+# CHECK-NEXT:   (1) <1, 0x4004fe, 7 bytes>
+# CHECK-NEXT:   (2) <2, 0x400505, 7 bytes>
+# CHECK-NEXT:   (3) <3, 0x40050c, 7 bytes>
+# CHECK-NEXT:   (4) <42, 0x400513, 14 bytes>
+# CHECK-NEXT:   (5) <5, 0x400521, 7 bytes>
+# CHECK-NEXT:   (6) <5, 0x400528, 7 bytes>
+# CHECK-NEXT:   (7) <6, 0x40052f, 7 bytes>

test/tools/llvm-mca/Binary/multiple-code-regions-obj.test

+# Note that the original source can be extracted from multiple-regions.elf via
+# objcopy --dump-section .test_source=test.c ./multiple-regions.elf
+
+# RUN: llvm-mca %p/Inputs/multiple-regions-obj.elf -dump-binary-regions | FileCheck %s
+
+# CHECK: .mca_code_regions:
+# CHECK-NEXT:   (1) <1, 0x3e, 7 bytes>
+# CHECK-NEXT:   (2) <2, 0x45, 7 bytes>
+# CHECK-NEXT:   (3) <3, 0x4c, 7 bytes>
+# CHECK-NEXT:   (4) <42, 0x53, 14 bytes>
+# CHECK-NEXT:   (5) <5, 0x61, 7 bytes>
+# CHECK-NEXT:   (6) <5, 0x68, 7 bytes>
+# CHECK-NEXT:   (7) <6, 0x6f, 7 bytes>

tools/llvm-mca/CodeRegion.h

class CodeRegion {
   // Source location range.
   llvm::SMLoc RangeStart;
   llvm::SMLoc RangeEnd;
 
   CodeRegion(const CodeRegion &) = delete;
   CodeRegion &operator=(const CodeRegion &) = delete;
 
 public:
+  CodeRegion() {}
   CodeRegion(llvm::StringRef Desc, llvm::SMLoc Start)
       : Description(Desc), RangeStart(Start), RangeEnd() {}
 
   void addInstruction(const llvm::MCInst &Instruction) {
     Instructions.emplace_back(Instruction);
   }
 
   llvm::SMLoc startLoc() const { return RangeStart; }
public:
   const_iterator begin() const { return Regions.cbegin(); }
   const_iterator end() const { return Regions.cend(); }
 
   void beginRegion(llvm::StringRef Description, llvm::SMLoc Loc);
   void endRegion(llvm::SMLoc Loc);
   void addInstruction(const llvm::MCInst &Instruction);
   llvm::SourceMgr &getSourceMgr() const { return SM; }
 
+  CodeRegion *createEmptyRegion() {
+    auto CR = llvm::make_unique<CodeRegion>();
+    auto CRPtr = CR.get();
+    Regions.push_back(std::move(CR));
+    return CRPtr;
+  }
+
   CodeRegions(llvm::SourceMgr &S) : SM(S) {
     // Create a default region for the input code sequence.
     addRegion("Default", llvm::SMLoc());
   }
 
   llvm::ArrayRef<llvm::MCInst> getInstructionSequence(unsigned Idx) const {
     return Regions[Idx]->getInstructions();
   }

tools/llvm-mca/CodeRegionGenerator.h

 /// CodeRegions from various types of input. llvm-mca only analyzes CodeRegions,
 /// so the classes here provide the input-to-CodeRegions translation.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_CODEREGION_GENERATOR_H
 #define LLVM_TOOLS_LLVM_MCA_CODEREGION_GENERATOR_H
 
+#include "BinaryCodeRegion.h"
 #include "CodeRegion.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
-#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include <memory>
+#include <string>
 
 namespace llvm {
 namespace mca {
 
 /// This class is responsible for parsing the input given to the llvm-mca
 /// driver, and converting that into a CodeRegions instance.
 class CodeRegionGenerator {
 protected:
AsmCodeRegionGenerator(const Target &T, SourceMgr &SM, MCContext &C,
                          const MCInstrInfo &I)
       : CodeRegionGenerator(SM), TheTarget(T), Ctx(C), MAI(A), STI(S), MCII(I),
         AssemblerDialect(0) {}
 
   unsigned getAssemblerDialect() const { return AssemblerDialect; }
   Expected<const CodeRegions &> parseCodeRegions() override;
 };
 
+/// This class is responsible for parsing input object files and generating
+/// a CodeRegions instance.
+class ObjFileCodeRegionGenerator final : public CodeRegionGenerator {
+  const Target &TheTarget;
+  MCContext &Ctx;
+  const MCSubtargetInfo &STI;
+  const MCObjectFileInfo &MOFI;
+  std::string InputFilename;
+  BinaryCodeRegions ObjRegions;
+
+  Error readMCACodeRegionsSection(const object::ObjectFile &O);
+  Error disassembleIntoRegions(const object::Binary &Bin);
+
+public:
+  ObjFileCodeRegionGenerator(const Target &T, SourceMgr &SM, MCContext &C,
+                             const MCSubtargetInfo &S,
+                             const MCObjectFileInfo &M, StringRef FileName)
+      : CodeRegionGenerator(SM), TheTarget(T), Ctx(C), STI(S), MOFI(M),
+        InputFilename(FileName) {}
+
+  Expected<const CodeRegions &> parseCodeRegions() override;
+  void dumpObjFileRegions() const { ObjRegions.dump(); }
+};
+
 } // namespace mca
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_MCA_CODEREGION_GENERATOR_H

tools/llvm-mca/CodeRegionGenerator.cpp

 /// This file defines classes responsible for generating llvm-mca
 /// CodeRegions from various types of input. llvm-mca only analyzes CodeRegions,
 /// so the classes here provide the input-to-CodeRegions translation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeRegionGenerator.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/MC/MCDisassembler.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCTargetOptions.h"
-#include "llvm/Support/Error.h"
+#include "llvm/Support/BinaryStreamReader.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/SMLoc.h"
 #include <memory>
 
 namespace llvm {
 namespace mca {
 
+#define DEBUG_TYPE "llvm-mca"
+using namespace llvm::object;
+
 // This virtual dtor serves as the anchor for the CodeRegionGenerator class.
 CodeRegionGenerator::~CodeRegionGenerator() {}
 
 // A comment consumer that parses strings.  The only valid tokens are strings.
 class MCACommentConsumer : public AsmCommentConsumer {
 public:
   CodeRegions &Regions;
 
Expected<const CodeRegions &> AsmCodeRegionGenerator::parseCodeRegions() {
   Parser->Run(false);
 
   // Get the assembler dialect from the input.  llvm-mca will use this as the
   // default dialect when printing reports.
   AssemblerDialect = Parser->getAssemblerDialect();
   return Regions;
 }
 
+// Struct to sort mca symbols.
+struct MCASym {
+  bool IsStartOfRegion;
+  uint64_t Address;
+  uint64_t ID;       // User defined value.
+  uint64_t Sequence; // Compiler generated value.
+};
+
+// Parse the symbol name in 'Sym' and create a MCASym instance in Syms.
+// This routine will return early if the symbol is not a llvm-mca region symbol.
+static void parseMCASym(const SymbolRef Sym, SmallVectorImpl<MCASym> &Syms) {
+  // Region markers are treated as unknown symbol types, skip
+  // any symbol type that is not an unknown.
+  auto SymType = Sym.getType();
+  if (!SymType || SymType.get() != SymbolRef::ST_Unknown)
+    return;
+
+  // Check the name and reject this symbol if it is not for llvm-mca.
+  auto MaybeName = Sym.getName();
+  if (!MaybeName)
+    return;
+  StringRef Name = MaybeName.get();
+  bool IsStart = Name.startswith(".mca_code_region_start.");
+  if (!IsStart && !Name.startswith(".mca_code_region_end."))
+    return;
+
+  // If we are this far we have a start or end llvm-mca symbol.
+  // Get the address from the SymbolRef.
+  auto MaybeAddr = Sym.getAddress();
+  if (!MaybeAddr)
+    return;
+  uint64_t Addr = MaybeAddr.get();
+
+  // Skip past the leading '.' in: .mca_code_region_{start,end}.<ID>.<SEQUENCE>
+  auto NameStr = Name.str();
+  size_t StrOffset = 1;
+
+  // Parse the user-defined ID integer.  This is the first number following
+  // the  next '.'  This ID is only used for report/comestic purposes.
+  StrOffset = NameStr.find('.', StrOffset);
+  if (StrOffset == std::string::npos)
+    return;
+  ++StrOffset;
+  uint64_t ID = atoi(NameStr.c_str() + StrOffset);
+
+  // Parse the compiler-defined Sequence integer.  This is the first number
+  // following the  next '.'  This value is used for sorting regions.
+  if ((StrOffset = NameStr.find('.', StrOffset)) == std::string::npos)
+    return;
+  ++StrOffset;
+  uint64_t Seq = atoi(NameStr.c_str() + StrOffset);
+
+  // Add the parsed symbol to the list of discovered llvm-mca symbols.
+  Syms.push_back({IsStart, Addr, ID, Seq});
+}
+
+Error ObjFileCodeRegionGenerator::readMCACodeRegionsSection(
+    const ObjectFile &O) {
+  // Parse the symbol table looking for .mca_code_region_{start,end}.
+  SmallVector<MCASym, 16> MCASyms;
+  for (const auto Sym : O.symbols())
+    parseMCASym(Sym, MCASyms);
+  if (MCASyms.size() % 2 != 0)
+    return make_error<StringError>("Odd number of .mca_code_regions.",
+                                   inconvertibleErrorCode());
+
+  // Sort symbols based on address and sequence number.  A region can end at
+  // one address and a new region can start at that same address.  This
+  // predicate takes that into account, by sorting on the compiler-generated
+  // sequence numbers for the region if the addresses have the same value.
+  llvm::sort(MCASyms, [](const MCASym &A, const MCASym &B) {
+    return (A.Address == B.Address) ? A.Sequence < B.Sequence
+                                    : A.Address < B.Address;
+  });
+
+#ifndef NDEBUG
+  LLVM_DEBUG(llvm::dbgs() << "Found " << MCASyms.size() << " MCA Symbols:\n");
+  for (auto M : MCASyms)
+    LLVM_DEBUG(llvm::dbgs()
+               << "  " << format_hex(M.Address, 2) << ", "
+               << "Seq:" << M.Sequence << ", "
+               << "ID: " << M.ID << ", "
+               << (M.IsStartOfRegion ? "StartOfRegion" : "EndOfRegion")
+               << '\n');
+#endif
+
+  // Turn the symbols into code regions.
+  for (size_t I = 0; I < MCASyms.size(); I += 2) {
+    auto StartSym = MCASyms[I];
+    auto EndSym = MCASyms[I + 1];
+    if (!StartSym.IsStartOfRegion || EndSym.IsStartOfRegion ||
+        StartSym.ID != EndSym.ID)
+      return make_error<StringError>("Invalid start/end region marker.  "
+                                     "Nested or empty regions are not allowed.",
+                                     inconvertibleErrorCode());
+    if (EndSym.Address - StartSym.Address)
+      ObjRegions.addRegion(StartSym.ID, StartSym.Address,
+                           EndSym.Address - StartSym.Address);
+  }
+
+  return Error::success();
+}
+
+// This utility class is used to sort the .text sections by increasing
+// address.
+struct SectionRange {
+  SectionRef Section;
+  size_t StartAddress;
+  size_t EndAddress;
+  bool operator<(const SectionRange &RHS) const {
+    return StartAddress < RHS.StartAddress;
+  }
+};
+
+// Populate Sections with the .text sections from O.
+static void createSectionList(const ObjectFile &O,
+                              SmallVectorImpl<SectionRange> &Sections) {
+  for (auto S = O.section_begin(), SE = O.section_end(); S != SE; ++S)
+    if (S->isText())
+      Sections.push_back({*S, S->getAddress(), S->getAddress() + S->getSize()});
+  sort(Sections, std::less<const SectionRange &>());
+}
+
+// Populate Region with instructions from Section.
+static void addInstructionsInRange(MCDisassembler &MCD,
+                                   const SectionRef Section,
+                                   BinaryCodeRegion &Region) {
+  StringRef SData;
+  if (Section.getContents(SData))
+    return;
+  auto Data = arrayRefFromStringRef(SData);
+  uint64_t NBytesRead = 0;
+  uint64_t BaseAddr = Section.getAddress();
+  for (uint64_t Offset = Region.getStartAddress() - BaseAddr, Size = 0;
+       Offset < Data.size() && NBytesRead < Region.getRegionLength();
+       Offset += Size) {
+    // Read in data at offset, it could be trash or it could be an inst.
+    MCInst I;
+    const ArrayRef<uint8_t> Slice = Data.slice(Offset);
+    MCDisassembler::DecodeStatus Status =
+        MCD.getInstruction(I, Size, Slice, Offset, nulls(), nulls());
+    if (Status == MCDisassembler::DecodeStatus::Success)
+      Region.addInstruction(I);
+
+    // Ensure progress by advancing 1 byte if we did not advance any.
+    if (Size == 0)
+      Size = 1;
+    NBytesRead += Size;
+  }
+}
+
+// Given a binary, scan the .mca_code_regions section to obtain a set of <id,
+// address, size> triples.  These triples are used here as ranges of
+// instructions.  The instructions within the ranges of that set are
+// disassembled into CodeRegions.  CodeRegions are what llvm-mca analyzes.
+Expected<const CodeRegions &> ObjFileCodeRegionGenerator::parseCodeRegions() {
+  // Create a disassembler.  We need to convert raw object code to MCInst.
+  std::unique_ptr<MCDisassembler> MCD =
+      std::unique_ptr<MCDisassembler>(TheTarget.createMCDisassembler(STI, Ctx));
+  if (!MCD)
+    return make_error<StringError>("Failed to initialize a disassembler.",
+                                   inconvertibleErrorCode());
+
+  // Get the input file as a binary object.
+  Expected<OwningBinary<Binary>> OB = createBinary(InputFilename);
+  if (!OB)
+    return std::move(OB.takeError());
+  Binary *Bin = OB->getBinary();
+  if (!Bin->isObject())
+    return make_error<StringError>("Expected object file.",
+                                   inconvertibleErrorCode());
+
+  // Cast the input binary into an object file representation.
+  const ObjectFile *O = cast<ObjectFile>(Bin);
+
+  // Read the code regions that the user wants to analyze.  These regions
+  // are specified in the llvm-mca code region section of the binary.
+  if (auto Err = readMCACodeRegionsSection(*O))
+    return Err;
+
+  if (ObjRegions.empty())
+    return make_error<StringError>(
+        "No llvm-mca code regions are defined in this binary.",
+        inconvertibleErrorCode());
+
+  // Create a table of sections sorted by the sections start address.
+  SmallVector<SectionRange, 4> SL;
+  createSectionList(*O, SL);
+
+  // Get the instructions that fall within each region.
+  for (auto &Region : ObjRegions) {
+    // Find the Section that contains the Region.
+    auto SItr = find_if(SL, [&Region](const SectionRange &S) {
+      return ((Region->getStartAddress() >= S.StartAddress) &&
+              ((Region->getStartAddress() + Region->getRegionLength()) <
+               S.EndAddress));
+    });
+    if (SItr != SL.end())
+      addInstructionsInRange(*MCD, SItr->Section, *Region);
+  }
+
+  // Get the CodeRegion from each ObjRegion.
+  ObjRegions.toCodeRegions(Regions);
+  return Regions;
+}
+
 } // namespace mca
 } // namespace llvm

tools/llvm-mca/llvm-mca.cpp

 #include "Views/DispatchStatistics.h"
 #include "Views/InstructionInfoView.h"
 #include "Views/RegisterFileStatistics.h"
 #include "Views/ResourcePressureView.h"
 #include "Views/RetireControlUnitStatistics.h"
 #include "Views/SchedulerStatistics.h"
 #include "Views/SummaryView.h"
 #include "Views/TimelineView.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/BinaryFormat/Magic.h"
+#include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCStreamer.h"
 #include "llvm/MCA/Context.h"
 #include "llvm/MCA/Pipeline.h"
 #include "llvm/MCA/Stages/EntryStage.h"
 #include "llvm/MCA/Stages/InstructionTables.h"
 #include "llvm/MCA/Support.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 
 using namespace llvm;
 
 static cl::OptionCategory ToolOptions("Tool Options");
 static cl::OptionCategory ViewOptions("View Options");
+static cl::OptionCategory DebugOptions("Debug Options");
 
 static cl::opt<std::string> InputFilename(cl::Positional,
                                           cl::desc("<input file>"),
                                           cl::cat(ToolOptions), cl::init("-"));
 
 static cl::opt<std::string> OutputFilename("o", cl::desc("Output filename"),
                                            cl::init("-"), cl::cat(ToolOptions),
                                            cl::value_desc("filename"));
static cl::opt<bool> EnableAllStats("all-stats",
                                     cl::desc("Print all hardware statistics"),
                                     cl::cat(ViewOptions), cl::init(false));
 
 static cl::opt<bool>
     EnableAllViews("all-views",
                    cl::desc("Print all views including hardware statistics"),
                    cl::cat(ViewOptions), cl::init(false));
 
+static cl::opt<bool> DumpBinaryRegions(
+    "dump-binary-regions",
+    cl::desc("Dump the contents of the .mca_code_regions section"),
+    cl::cat(DebugOptions), cl::init(false));
+
 namespace {
 
 const Target *getTarget(const char *ProgName) {
   if (TripleName.empty())
     TripleName = Triple::normalize(sys::getDefaultTargetTriple());
   Triple TheTriple(TripleName);
 
   // Get the target specific parser.

 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
   // Initialize targets and assembly parsers.
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllAsmParsers();
+  InitializeAllDisassemblers();
 
   // Enable printing of available targets when flag --version is specified.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
-  cl::HideUnrelatedOptions({&ToolOptions, &ViewOptions});
+  cl::HideUnrelatedOptions({&ToolOptions, &ViewOptions, &DebugOptions});
 
   // Parse flags and initialize target options.
   cl::ParseCommandLineOptions(argc, argv,
                               "llvm machine code performance analyzer.\n");
 
   // Get the target from the triple. If a triple is not specified, then select
   // the default triple for the host. If the triple doesn't correspond to any
   // registered target, then exit with an error message.
int main(int argc, char **argv) {
   if (std::error_code EC = BufferPtr.getError()) {
     WithColor::error() << InputFilename << ": " << EC.message() << '\n';
     return 1;
   }
 
   // Apply overrides to llvm-mca specific options.
   processViewOptions();
 
-  SourceMgr SrcMgr;
-
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
+  SourceMgr SrcMgr;
   SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc());
 
   std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
   assert(MRI && "Unable to create target register info!");
 
   std::unique_ptr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(*MRI, TripleName));
   assert(MAI && "Unable to create target asm info!");
 
   MCObjectFileInfo MOFI;
   MCContext Ctx(MAI.get(), MRI.get(), &MOFI, &SrcMgr);
   MOFI.InitMCObjectFileInfo(TheTriple, /* PIC= */ false, Ctx);
 
   std::unique_ptr<buffer_ostream> BOS;
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
-
   std::unique_ptr<MCInstrAnalysis> MCIA(
       TheTarget->createMCInstrAnalysis(MCII.get()));
 
   if (!MCPU.compare("native"))
     MCPU = llvm::sys::getHostCPUName();
 
   std::unique_ptr<MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TripleName, MCPU, /* FeaturesStr */ ""));
if (!STI->getSchedModel().hasInstrSchedModel()) {
 
     if (STI->getSchedModel().InstrItineraries)
       WithColor::note()
           << "cpu '" << MCPU << "' provides itineraries. However, "
           << "instruction itineraries are currently unsupported.\n";
     return 1;
   }
 
+  // Automatically detect object files if the input file is not STDIN.
+  bool InputIsBinary = false;
+  if (InputFilename != "-") {
+    file_magic Presto;
+    if (auto EC = identify_magic(InputFilename, Presto)) {
+      WithColor::error() << "Failed to identify input file's magic number.\n";
+      return 1;
+    } else
+      InputIsBinary = Presto.is_object();
+  }
+
+  // Create a generator for the input passed to llvm-mca.
+  std::unique_ptr<mca::CodeRegionGenerator> CRG;
+  if (InputIsBinary)
+    CRG = llvm::make_unique<mca::ObjFileCodeRegionGenerator>(
+        *TheTarget, SrcMgr, Ctx, *STI, MOFI, InputFilename);
+  else
+    CRG = llvm::make_unique<mca::AsmCodeRegionGenerator>(
+        *TheTarget, SrcMgr, Ctx, *MAI, *STI, *MCII);
+
+  // Populate the code regions using the generator.  A region is a collection
+  // of instructions.
+  Expected<const mca::CodeRegions &> RegionsOrErr = CRG->parseCodeRegions();
+
   // Parse the input and create CodeRegions that llvm-mca can analyze.
-  mca::AsmCodeRegionGenerator CRG(*TheTarget, SrcMgr, Ctx, *MAI, *STI, *MCII);
-  Expected<const mca::CodeRegions &> RegionsOrErr = CRG.parseCodeRegions();
   if (!RegionsOrErr) {
     if (auto Err =
             handleErrors(RegionsOrErr.takeError(), [](const StringError &E) {
               WithColor::error() << E.getMessage() << '\n';
             })) {
       // Default case.
       WithColor::error() << toString(std::move(Err)) << '\n';
     }
     return 1;
   }
   const mca::CodeRegions &Regions = *RegionsOrErr;
   if (Regions.empty()) {
     WithColor::error() << "no assembly instructions found.\n";
     return 1;
   }
 
-  // Now initialize the output file.
+  // Optionally dump the code regions if the input file was an object file
+  // (this is primarily for debugging and testing).
+  if (InputIsBinary && DumpBinaryRegions) {
+    auto G = static_cast<mca::ObjFileCodeRegionGenerator *>(CRG.get());
+    G->dumpObjFileRegions();
+    return 0;
+  }
+
+  // If the input is ASM, then obtain the dialect used in that file.
+  unsigned AssemblerDialect = 0;
+  if (!InputIsBinary) {
+    auto G = static_cast<mca::AsmCodeRegionGenerator *>(CRG.get());
+    AssemblerDialect = G->getAssemblerDialect();
+  }
+  if (OutputAsmVariant >= 0)
+    AssemblerDialect = static_cast<unsigned>(OutputAsmVariant);
+
+  // Initialize the output file.
   auto OF = getOutputStream();
   if (std::error_code EC = OF.getError()) {
     WithColor::error() << EC.message() << '\n';
     return 1;
   }
 
-  unsigned AssemblerDialect = CRG.getAssemblerDialect();
-  if (OutputAsmVariant >= 0)
-    AssemblerDialect = static_cast<unsigned>(OutputAsmVariant);
   std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
       Triple(TripleName), AssemblerDialect, *MAI, *MCII, *MRI));
   if (!IP) {
     WithColor::error()
         << "unable to create instruction printer for target triple '"
         << TheTriple.normalize() << "' with assembly variant "
         << AssemblerDialect << ".\n";
     return 1;