RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-01-26 20:57:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert r237954, "Resubmit r237708 (MIR Serialization: print and parse LLVM IR using MIR format)."

Browse Source 
It brought cyclic dependencies between LLVMCodeGen and LLVMMIR.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@238007 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
NAKAMURA Takumi 2015-05-22 07:17:07 +00:00
parent f5e0674d06
commit b6b98c12d5
21 changed files with 11 additions and 414 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
include/llvm/CodeGen/MIR/MIRParser.h
View File

@ -1,52 +0,0 @@
//===- MIRParser.h - MIR serialization format parser ----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This MIR serialization library is currently a work in progress. It can't
// serialize machine functions at this time.
//
// This file declares the functions that parse the MIR serialization format
// files.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_MIR_MIRPARSER_H
#define LLVM_CODEGEN_MIR_MIRPARSER_H
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/MemoryBuffer.h"
#include <memory>
namespace llvm {
class SMDiagnostic;
/// This function is the main interface to the MIR serialization format parser.
///
/// It reads a YAML file that has an optional LLVM IR and returns an LLVM
/// module.
/// \param Filename - The name of the file to parse.
/// \param Error - Error result info.
/// \param Context - Context in which to allocate globals info.
std::unique_ptr<Module> parseMIRFile(StringRef Filename, SMDiagnostic &Error,
LLVMContext &Context);
/// This function is another interface to the MIR serialization format parser.
///
/// It parses the optional LLVM IR in the given buffer, and returns an LLVM
/// module.
/// \param Contents - The MemoryBuffer containing the machine level IR.
/// \param Error - Error result info.
/// \param Context - Context in which to allocate globals info.
std::unique_ptr<Module> parseMIR(std::unique_ptr<MemoryBuffer> Contents,
SMDiagnostic &Error, LLVMContext &Context);
} // end namespace llvm
#endif

8
include/llvm/CodeGen/Passes.h
View File

@ -374,10 +374,6 @@ namespace llvm {
createMachineFunctionPrinterPass(raw_ostream &OS,
const std::string &Banner ="");
/// MIRPrinting pass - this pass prints out the LLVM IR into the given stream
/// using the MIR serialization format.
MachineFunctionPass *createPrintMIRPass(raw_ostream &OS);
/// createCodeGenPreparePass - Transform the code to expose more pattern
/// matching during instruction selection.
FunctionPass *createCodeGenPreparePass(const TargetMachine *TM = nullptr);
@ -492,10 +488,6 @@ namespace llvm {
/// MachineFunctionPrinterPass - This pass prints out MachineInstr's.
extern char &MachineFunctionPrinterPassID;
/// MIRPrintingPass - this pass prints out the LLVM IR using the MIR
/// serialization format.
extern char &MIRPrintingPassID;
/// TailDuplicate - Duplicate blocks with unconditional branches
/// into tails of their predecessors.
extern char &TailDuplicateID;

1
include/llvm/InitializePasses.h
View File

@ -289,7 +289,6 @@ void initializeLoopVectorizePass(PassRegistry&);
void initializeSLPVectorizerPass(PassRegistry&);
void initializeBBVectorizePass(PassRegistry&);
void initializeMachineFunctionPrinterPassPass(PassRegistry&);
void initializeMIRPrintingPassPass(PassRegistry&);
void initializeStackMapLivenessPass(PassRegistry&);
void initializeMachineCombinerPass(PassRegistry &);
void initializeLoadCombinePass(PassRegistry&);

3
include/llvm/Support/YAMLTraits.h
View File

@ -1090,9 +1090,6 @@ public:
bool setCurrentDocument();
bool nextDocument();
/// Returns the current node that's being parsed by the YAML Parser.
const Node *getCurrentNode() const;
private:
llvm::SourceMgr SrcMgr; // must be before Strm
std::unique_ptr<llvm::yaml::Stream> Strm;

1
lib/CodeGen/CMakeLists.txt
View File

@ -129,4 +129,3 @@ add_dependencies(LLVMCodeGen intrinsics_gen)
add_subdirectory(SelectionDAG)
add_subdirectory(AsmPrinter)
add_subdirectory(MIR)

4
lib/CodeGen/LLVMBuild.txt
View File

@ -16,10 +16,10 @@
;===------------------------------------------------------------------------===;
[common]
subdirectories = AsmPrinter SelectionDAG MIR
subdirectories = AsmPrinter SelectionDAG
[component_0]
type = Library
name = CodeGen
parent = Libraries
required_libraries = Analysis Core MC Scalar Support Target TransformUtils MIR
required_libraries = Analysis Core MC Scalar Support Target TransformUtils

7
lib/CodeGen/LLVMTargetMachine.cpp
View File

@ -150,7 +150,12 @@ bool LLVMTargetMachine::addPassesToEmitFile(
return true;
if (StopAfter) {
PM.add(createPrintMIRPass(outs()));
// FIXME: The intent is that this should eventually write out a YAML file,
// containing the LLVM IR, the machine-level IR (when stopping after a
// machine-level pass), and whatever other information is needed to
// deserialize the code and resume compilation. For now, just write the
// LLVM IR.
PM.add(createPrintModulePass(Out));
return false;
}

7
lib/CodeGen/MIR/CMakeLists.txt
View File

@ -1,7 +0,0 @@
add_llvm_library(LLVMMIR
MIRPrinter.cpp
MIRPrintingPass.cpp
MIRParser.cpp
)
add_dependencies(LLVMMIR intrinsics_gen)

22
lib/CodeGen/MIR/LLVMBuild.txt
View File

@ -1,22 +0,0 @@
;===- ./lib/CodeGen/MIR/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 = Library
name = MIR
parent = CodeGen
required_libraries = Core Support Target AsmParser

90
lib/CodeGen/MIR/MIRParser.cpp
View File

@ -1,90 +0,0 @@
//===- MIRParser.cpp - MIR serialization format parser implementation -----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the class that parses the optional LLVM IR and machine
// functions that are stored in MIR files.
//
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/MIR/MIRParser.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/AsmParser/Parser.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/SMLoc.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/YAMLTraits.h"
#include <memory>
using namespace llvm;
namespace {
/// This class implements the parsing of LLVM IR that's embedded inside a MIR
/// file.
class MIRParserImpl {
SourceMgr SM;
StringRef Filename;
LLVMContext &Context;
public:
MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents, StringRef Filename,
LLVMContext &Context);
/// Try to parse the optional LLVM module in the MIR file.
///
/// Return null if an error occurred while parsing the LLVM module.
std::unique_ptr<Module> parseLLVMModule(SMDiagnostic &Error);
};
} // end anonymous namespace
MIRParserImpl::MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
StringRef Filename, LLVMContext &Context)
: SM(), Filename(Filename), Context(Context) {
SM.AddNewSourceBuffer(std::move(Contents), SMLoc());
}
std::unique_ptr<Module> MIRParserImpl::parseLLVMModule(SMDiagnostic &Error) {
yaml::Input In(SM.getMemoryBuffer(SM.getMainFileID())->getBuffer());
// Parse the block scalar manually so that we can return unique pointer
// without having to go trough YAML traits.
if (In.setCurrentDocument()) {
if (const auto *BSN =
dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
return parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
Context);
}
}
// Create an new, empty module.
return llvm::make_unique<Module>(Filename, Context);
}
std::unique_ptr<Module> llvm::parseMIRFile(StringRef Filename,
SMDiagnostic &Error,
LLVMContext &Context) {
auto FileOrErr = MemoryBuffer::getFile(Filename);
if (std::error_code EC = FileOrErr.getError()) {
Error = SMDiagnostic(Filename, SourceMgr::DK_Error,
"Could not open input file: " + EC.message());
return std::unique_ptr<Module>();
}
return parseMIR(std::move(FileOrErr.get()), Error, Context);
}
std::unique_ptr<Module> llvm::parseMIR(std::unique_ptr<MemoryBuffer> Contents,
SMDiagnostic &Error,
LLVMContext &Context) {
auto Filename = Contents->getBufferIdentifier();
MIRParserImpl Parser(std::move(Contents), Filename, Context);
return Parser.parseLLVMModule(Error);
}

66
lib/CodeGen/MIR/MIRPrinter.cpp
View File

@ -1,66 +0,0 @@
//===- MIRPrinter.cpp - MIR serialization format printer ------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the class that prints out the LLVM IR and machine
// functions using the MIR serialization format.
//
//===----------------------------------------------------------------------===//
#include "MIRPrinter.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/YAMLTraits.h"
using namespace llvm;
namespace {
/// This class prints out the LLVM IR using the MIR serialization format and
/// YAML I/O.
class MIRPrinter {
raw_ostream &OS;
public:
MIRPrinter(raw_ostream &OS);
void printModule(const Module &Mod);
};
} // end anonymous namespace
namespace llvm {
namespace yaml {
/// This struct serializes the LLVM IR module.
template <> struct BlockScalarTraits<Module> {
static void output(const Module &Mod, void *Ctxt, raw_ostream &OS) {
Mod.print(OS, nullptr);
}
static StringRef input(StringRef Str, void *Ctxt, Module &Mod) {
llvm_unreachable("LLVM Module is supposed to be parsed separately");
return "";
}
};
} // end namespace yaml
} // end namespace llvm
MIRPrinter::MIRPrinter(raw_ostream &OS) : OS(OS) {}
void MIRPrinter::printModule(const Module &Mod) {
yaml::Output Out(OS);
Out << const_cast<Module &>(Mod);
}
void llvm::printMIR(raw_ostream &OS, const Module &Mod) {
MIRPrinter Printer(OS);
Printer.printModule(Mod);
}

29
lib/CodeGen/MIR/MIRPrinter.h
View File

@ -1,29 +0,0 @@
//===- MIRPrinter.h - MIR serialization format printer --------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the function that prints out the LLVM IR using the MIR
// serialization format.
// TODO: Print out machine functions.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIB_CODEGEN_MIR_MIRPRINTER_H
#define LLVM_LIB_CODEGEN_MIR_MIRPRINTER_H
namespace llvm {
class Module;
class raw_ostream;
/// Print LLVM IR using the MIR serialization format to the given output stream.
void printMIR(raw_ostream &OS, const Module &Mod);
} // end namespace llvm
#endif

66
lib/CodeGen/MIR/MIRPrintingPass.cpp
View File

@ -1,66 +0,0 @@
//===- MIRPrintingPass.cpp - Pass that prints out using the MIR format ----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements a pass that prints out the LLVM module using the MIR
// serialization format.
//
//===----------------------------------------------------------------------===//
#include "MIRPrinter.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
namespace {
/// This pass prints out the LLVM IR to an output stream using the MIR
/// serialization format.
struct MIRPrintingPass : public MachineFunctionPass {
static char ID;
raw_ostream &OS;
MIRPrintingPass() : MachineFunctionPass(ID), OS(dbgs()) {}
MIRPrintingPass(raw_ostream &OS) : MachineFunctionPass(ID), OS(OS) {}
const char *getPassName() const override { return "MIR Printing Pass"; }
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesAll();
MachineFunctionPass::getAnalysisUsage(AU);
}
virtual bool runOnMachineFunction(MachineFunction &MF) override {
// TODO: Print out the machine function.
return false;
}
virtual bool doFinalization(Module &M) override {
printMIR(OS, M);
return false;
}
};
char MIRPrintingPass::ID = 0;
} // end anonymous namespace
char &llvm::MIRPrintingPassID = MIRPrintingPass::ID;
INITIALIZE_PASS(MIRPrintingPass, "mir-printer", "MIR Printer", false, false)
namespace llvm {
MachineFunctionPass *createPrintMIRPass(raw_ostream &OS) {
return new MIRPrintingPass(OS);
}
} // end namespace llvm

13
lib/CodeGen/MIR/Makefile
View File

@ -1,13 +0,0 @@
##===- lib/CodeGen/MIR/Makefile ----------------------------*- Makefile -*-===##
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
##===----------------------------------------------------------------------===##
LEVEL = ../../..
LIBRARYNAME = LLVMMIR
include $(LEVEL)/Makefile.common

2
lib/CodeGen/Makefile
View File

@ -9,7 +9,7 @@
LEVEL = ../..
LIBRARYNAME = LLVMCodeGen
PARALLEL_DIRS = SelectionDAG AsmPrinter MIR
PARALLEL_DIRS = SelectionDAG AsmPrinter
BUILD_ARCHIVE = 1
include $(LEVEL)/Makefile.common

4
lib/Support/YAMLTraits.cpp
View File

@ -97,10 +97,6 @@ bool Input::nextDocument() {
return ++DocIterator != Strm->end();
}
const Node *Input::getCurrentNode() const {
return CurrentNode ? CurrentNode->_node : nullptr;
}
bool Input::mapTag(StringRef Tag, bool Default) {
std::string foundTag = CurrentNode->_node->getVerbatimTag();
if (foundTag.empty()) {

3
test/CodeGen/Generic/stop-after.ll
View File

@ -1,10 +1,9 @@
; RUN: llc < %s -debug-pass=Structure -stop-after=loop-reduce -o /dev/null 2>&1 | FileCheck %s -check-prefix=STOP
; RUN: llc < %s -debug-pass=Structure -start-after=loop-reduce -o /dev/null 2>&1 | FileCheck %s -check-prefix=START
; STOP: -loop-reduce
; STOP: -loop-reduce -print-module
; STOP: Loop Strength Reduction
; STOP-NEXT: Machine Function Analysis
; STOP-NEXT: MIR Printing Pass
; START: -machine-branch-prob -gc-lowering
; START: FunctionPass Manager

2
test/CodeGen/MIR/lit.local.cfg
View File

@ -1,2 +0,0 @@
config.suffixes = ['.mir']

32
test/CodeGen/MIR/llvmIR.mir
View File

@ -1,32 +0,0 @@
# RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s
# This test ensures that the LLVM IR that's embedded with MIR is parsed
# correctly.
--- |
; CHECK: define i32 @foo(i32 %x, i32 %y)
; CHECK: %z = alloca i32, align 4
; CHECK: store i32 %x, i32* %z, align 4
; CHECK: br label %Test
; CHECK: Test:
; CHECK: %m = load i32, i32* %z, align 4
; CHECK: %cond = icmp eq i32 %y, %m
; CHECK: br i1 %cond, label %IfEqual, label %IfUnequal
; CHECK: IfEqual:
; CHECK: ret i32 1
; CHECK: IfUnequal:
; CHECK: ret i32 0
define i32 @foo(i32 %x, i32 %y) {
%z = alloca i32, align 4
store i32 %x, i32* %z, align 4
br label %Test
Test:
%m = load i32, i32* %z, align 4
%cond = icmp eq i32 %y, %m
br i1 %cond, label %IfEqual, label %IfUnequal
IfEqual:
ret i32 1
IfUnequal:
ret i32 0
}
...

5
test/CodeGen/MIR/llvmIRMissing.mir
View File

@ -1,5 +0,0 @@
# RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s
# This test ensures that the MIR parser accepts files without the LLVM IR.
---
...

8
tools/llc/llc.cpp
View File

@ -20,7 +20,6 @@
#include "llvm/CodeGen/CommandFlags.h"
#include "llvm/CodeGen/LinkAllAsmWriterComponents.h"
#include "llvm/CodeGen/LinkAllCodegenComponents.h"
#include "llvm/CodeGen/MIR/MIRParser.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/IRPrintingPasses.h"
#include "llvm/IR/LLVMContext.h"
@ -110,8 +109,6 @@ GetOutputStream(const char *TargetName, Triple::OSType OS,
StringRef IFN = InputFilename;
if (IFN.endswith(".bc") || IFN.endswith(".ll"))
OutputFilename = IFN.drop_back(3);
else if (IFN.endswith(".mir"))
OutputFilename = IFN.drop_back(4);
else
OutputFilename = IFN;
@ -217,10 +214,7 @@ static int compileModule(char **argv, LLVMContext &Context) {
// If user just wants to list available options, skip module loading
if (!SkipModule) {
if (StringRef(InputFilename).endswith_lower(".mir"))
M = parseMIRFile(InputFilename, Err, Context);
else
M = parseIRFile(InputFilename, Err, Context);
M = parseIRFile(InputFilename, Err, Context);
if (!M) {
Err.print(argv[0], errs());
return 1;