tools/llvm-exegesis/lib/SnippetFile.cpp - llvm-project/llvm - Git at Google

 //===-- SnippetFile.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "SnippetFile.h"
 #include "BenchmarkRunner.h"
 #include "Error.h"
 #include "Target.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include <string>

 #ifdef __linux__
 #include <unistd.h>
 #endif // __linux__

 namespace llvm {
 namespace exegesis {
 namespace {

 // An MCStreamer that reads a BenchmarkCode definition from a file.
 class BenchmarkCodeStreamer : public MCStreamer, public AsmCommentConsumer {
 public:
   explicit BenchmarkCodeStreamer(
       MCContext *Context, const DenseMap<StringRef, unsigned> &RegNameToRegNo,
       BenchmarkCode *Result)
       : MCStreamer(*Context), RegNameToRegNo(RegNameToRegNo), Result(Result) {}

   // Implementation of the MCStreamer interface. We only care about
   // instructions.
   void emitInstruction(const MCInst &Instruction,
                        const MCSubtargetInfo &STI) override {
     Result->Key.Instructions.push_back(Instruction);
   }

   // Implementation of the AsmCommentConsumer.
   void HandleComment(SMLoc Loc, StringRef CommentText) override {
     CommentText = CommentText.trim();
     if (!CommentText.consume_front("LLVM-EXEGESIS-"))
       return;
     if (CommentText.consume_front("DEFREG")) {
       // LLVM-EXEGESIS-DEFREF <reg> <hex_value>
       RegisterValue RegVal;
       SmallVector<StringRef, 2> Parts;
       CommentText.split(Parts, ' ', /*unlimited splits*/ -1,
                         /*do not keep empty strings*/ false);
       if (Parts.size() != 2) {
         errs() << "invalid comment 'LLVM-EXEGESIS-DEFREG " << CommentText
                << "', expected two parameters <REG> <HEX_VALUE>\n";
         ++InvalidComments;
         return;
       }
       if (!(RegVal.Register = findRegisterByName(Parts[0].trim()))) {
         errs() << "unknown register '" << Parts[0]
                << "' in 'LLVM-EXEGESIS-DEFREG " << CommentText << "'\n";
         ++InvalidComments;
         return;
       }
       const StringRef HexValue = Parts[1].trim();
       RegVal.Value = APInt(
           /* each hex digit is 4 bits */ HexValue.size() * 4, HexValue, 16);
       Result->Key.RegisterInitialValues.push_back(std::move(RegVal));
       return;
     }
     if (CommentText.consume_front("LIVEIN")) {
       // LLVM-EXEGESIS-LIVEIN <reg>
       const auto RegName = CommentText.ltrim();
       if (unsigned Reg = findRegisterByName(RegName))
         Result->LiveIns.push_back(Reg);
       else {
         errs() << "unknown register '" << RegName
                << "' in 'LLVM-EXEGESIS-LIVEIN " << CommentText << "'\n";
         ++InvalidComments;
       }
       return;
     }
     if (CommentText.consume_front("MEM-DEF")) {
       // LLVM-EXEGESIS-MEM-DEF <name> <size> <value>
       SmallVector<StringRef, 3> Parts;
       CommentText.split(Parts, ' ', -1, false);
       if (Parts.size() != 3) {
         errs() << "invalid comment 'LLVM-EXEGESIS-MEM-DEF " << CommentText
                << "', expected three parameters <NAME> <SIZE> <VALUE>";
         ++InvalidComments;
         return;
       }
       const StringRef HexValue = Parts[2].trim();
       MemoryValue MemVal;
       MemVal.SizeBytes = std::stol(Parts[1].trim().str());
       if (HexValue.size() % 2 != 0) {
         errs() << "invalid comment 'LLVM-EXEGESIS-MEM-DEF " << CommentText
                << "', expected <VALUE> to contain a whole number of bytes";
       }
       MemVal.Value = APInt(HexValue.size() * 4, HexValue, 16);
       MemVal.Index = Result->Key.MemoryValues.size();
       Result->Key.MemoryValues[Parts[0].trim().str()] = MemVal;
       return;
     }
     if (CommentText.consume_front("MEM-MAP")) {
       // LLVM-EXEGESIS-MEM-MAP <value name> <address>
       SmallVector<StringRef, 2> Parts;
       CommentText.split(Parts, ' ', -1, false);
       if (Parts.size() != 2) {
         errs() << "invalid comment 'LLVM-EXEGESIS-MEM-MAP " << CommentText
                << "', expected two parameters <VALUE NAME> <ADDRESS>";
         ++InvalidComments;
         return;
       }
       MemoryMapping MemMap;
       MemMap.MemoryValueName = Parts[0].trim().str();
       MemMap.Address = std::stol(Parts[1].trim().str());

 #ifdef __linux__
       // Validate that the annotation is a multiple of the platform's page
       // size.
       if (MemMap.Address % getpagesize() != 0) {
         errs() << "invalid comment 'LLVM-EXEGESIS-MEM-MAP " << CommentText
                << "', expected <ADDRESS> to be a multiple of the platform page "
                   "size.";
         ++InvalidComments;
         return;
       }
 #endif // __linux__

       // validate that the annotation refers to an already existing memory
       // definition
       auto MemValIT = Result->Key.MemoryValues.find(Parts[0].trim().str());
       if (MemValIT == Result->Key.MemoryValues.end()) {
         errs() << "invalid comment 'LLVM-EXEGESIS-MEM-MAP " << CommentText
                << "', expected <VALUE NAME> to contain the name of an already "
                   "specified memory definition";
         ++InvalidComments;
         return;
       }
       Result->Key.MemoryMappings.push_back(std::move(MemMap));
       return;
     }
     if (CommentText.consume_front("SNIPPET-ADDRESS")) {
       // LLVM-EXEGESIS-SNIPPET-ADDRESS <address>
       if (!to_integer<intptr_t>(CommentText.trim(), Result->Key.SnippetAddress,
                                 16)) {
         errs() << "invalid comment 'LLVM-EXEGESIS-SNIPPET-ADDRESS "
                << CommentText
                << "', expected <ADDRESS> to contain a valid integer in "
                   "hexadecimal format";
         ++InvalidComments;
         return;
       }

 #ifdef __linux__
       // Validate that the address in the annotation is a multiple of the
       // platform's page size.
       if (Result->Key.SnippetAddress % getpagesize() != 0) {
         errs() << "invalid comment 'LLVM-EXEGESIS-SNIPPET-ADDRESS "
                << CommentText
                << ", expected <ADDRESS> to be a multiple of the platform page "
                   "size.";
         ++InvalidComments;
         return;
       }
 #endif // __linux__

       return;
     }
     if (CommentText.consume_front("LOOP-REGISTER")) {
       // LLVM-EXEGESIS-LOOP-REGISTER <loop register>
       unsigned LoopRegister;

       if (!(LoopRegister = findRegisterByName(CommentText.trim()))) {
         errs() << "unknown register '" << CommentText
                << "' in 'LLVM-EXEGESIS-LOOP-REGISTER " << CommentText << "'\n";
         ++InvalidComments;
         return;
       }

       Result->Key.LoopRegister = LoopRegister;
       return;
     }
   }

   unsigned numInvalidComments() const { return InvalidComments; }

 private:
   // We only care about instructions, we don't implement this part of the API.
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         Align ByteAlignment) override {}
   bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
     return false;
   }
   void emitValueToAlignment(Align Alignment, int64_t Value, unsigned ValueSize,
                             unsigned MaxBytesToEmit) override {}
   void emitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                     Align ByteAlignment, SMLoc Loc) override {}

   unsigned findRegisterByName(const StringRef RegName) const {
     auto Iter = RegNameToRegNo.find(RegName);
     if (Iter != RegNameToRegNo.end())
       return Iter->second;
     errs() << "'" << RegName
            << "' is not a valid register name for the target\n";
     return 0;
   }

   const DenseMap<StringRef, unsigned> &RegNameToRegNo;
   BenchmarkCode *const Result;
   unsigned InvalidComments = 0;
 };

 } // namespace

 // Reads code snippets from file `Filename`.
 Expected<std::vector<BenchmarkCode>> readSnippets(const LLVMState &State,
                                                   StringRef Filename) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
       MemoryBuffer::getFileOrSTDIN(Filename);
   if (std::error_code EC = BufferPtr.getError()) {
     return make_error<Failure>("cannot read snippet: " + Filename + ": " +
                                EC.message());
   }
   SourceMgr SM;
   SM.AddNewSourceBuffer(std::move(BufferPtr.get()), SMLoc());

   BenchmarkCode Result;

   // Ensure that there is a default loop register value specified.
   Result.Key.LoopRegister =
       State.getExegesisTarget().getDefaultLoopCounterRegister(
           State.getTargetMachine().getTargetTriple());

   const TargetMachine &TM = State.getTargetMachine();
   MCContext Context(TM.getTargetTriple(), TM.getMCAsmInfo(),
                     TM.getMCRegisterInfo(), TM.getMCSubtargetInfo());
   std::unique_ptr<MCObjectFileInfo> ObjectFileInfo(
       TM.getTarget().createMCObjectFileInfo(Context, /*PIC=*/false));
   Context.setObjectFileInfo(ObjectFileInfo.get());
   Context.initInlineSourceManager();
   BenchmarkCodeStreamer Streamer(&Context, State.getRegNameToRegNoMapping(),
                                  &Result);

   std::string Error;
   raw_string_ostream ErrorStream(Error);
   formatted_raw_ostream InstPrinterOStream(ErrorStream);
   const std::unique_ptr<MCInstPrinter> InstPrinter(
       TM.getTarget().createMCInstPrinter(
           TM.getTargetTriple(), TM.getMCAsmInfo()->getAssemblerDialect(),
           *TM.getMCAsmInfo(), *TM.getMCInstrInfo(), *TM.getMCRegisterInfo()));
   // The following call will take care of calling Streamer.setTargetStreamer.
   TM.getTarget().createAsmTargetStreamer(Streamer, InstPrinterOStream,
                                          InstPrinter.get(),
                                          TM.Options.MCOptions.AsmVerbose);
   if (!Streamer.getTargetStreamer())
     return make_error<Failure>("cannot create target asm streamer");

   const std::unique_ptr<MCAsmParser> AsmParser(
       createMCAsmParser(SM, Context, Streamer, *TM.getMCAsmInfo()));
   if (!AsmParser)
     return make_error<Failure>("cannot create asm parser");
   AsmParser->getLexer().setCommentConsumer(&Streamer);

   const std::unique_ptr<MCTargetAsmParser> TargetAsmParser(
       TM.getTarget().createMCAsmParser(*TM.getMCSubtargetInfo(), *AsmParser,
                                        *TM.getMCInstrInfo(),
                                        MCTargetOptions()));

   if (!TargetAsmParser)
     return make_error<Failure>("cannot create target asm parser");
   AsmParser->setTargetParser(*TargetAsmParser);

   if (AsmParser->Run(false))
     return make_error<Failure>("cannot parse asm file");
   if (Streamer.numInvalidComments())
     return make_error<Failure>(Twine("found ")
                                    .concat(Twine(Streamer.numInvalidComments()))
                                    .concat(" invalid LLVM-EXEGESIS comments"));
   return std::vector<BenchmarkCode>{std::move(Result)};
 }

 } // namespace exegesis
 } // namespace llvm
	//===-- SnippetFile.cpp ------------------------------------------ C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "SnippetFile.h"
	#include "BenchmarkRunner.h"
	#include "Error.h"
	#include "Target.h"
	#include "llvm/MC/MCContext.h"
	#include "llvm/MC/MCInstPrinter.h"
	#include "llvm/MC/MCObjectFileInfo.h"
	#include "llvm/MC/MCParser/MCAsmLexer.h"
	#include "llvm/MC/MCParser/MCAsmParser.h"
	#include "llvm/MC/MCParser/MCTargetAsmParser.h"
	#include "llvm/MC/MCRegisterInfo.h"
	#include "llvm/MC/MCStreamer.h"
	#include "llvm/MC/TargetRegistry.h"
	#include "llvm/Support/Format.h"
	#include "llvm/Support/Path.h"
	#include "llvm/Support/SourceMgr.h"
	#include <string>

	#ifdef __linux__
	#include <unistd.h>
	#endif // __linux__

	namespace llvm {
	namespace exegesis {
	namespace {

	// An MCStreamer that reads a BenchmarkCode definition from a file.
	class BenchmarkCodeStreamer : public MCStreamer, public AsmCommentConsumer {
	public:
	explicit BenchmarkCodeStreamer(
	MCContext *Context, const DenseMap<StringRef, unsigned> &RegNameToRegNo,
	BenchmarkCode *Result)
	: MCStreamer(*Context), RegNameToRegNo(RegNameToRegNo), Result(Result) {}

	// Implementation of the MCStreamer interface. We only care about
	// instructions.
	void emitInstruction(const MCInst &Instruction,
	const MCSubtargetInfo &STI) override {
	Result->Key.Instructions.push_back(Instruction);
	}

	// Implementation of the AsmCommentConsumer.
	void HandleComment(SMLoc Loc, StringRef CommentText) override {
	CommentText = CommentText.trim();
	if (!CommentText.consume_front("LLVM-EXEGESIS-"))
	return;
	if (CommentText.consume_front("DEFREG")) {
	// LLVM-EXEGESIS-DEFREF <reg> <hex_value>
	RegisterValue RegVal;
	SmallVector<StringRef, 2> Parts;
	CommentText.split(Parts, ' ', /unlimited splits/ -1,
	/do not keep empty strings/ false);
	if (Parts.size() != 2) {
	errs() << "invalid comment 'LLVM-EXEGESIS-DEFREG " << CommentText
	<< "', expected two parameters <REG> <HEX_VALUE>\n";
	++InvalidComments;
	return;
	}
	if (!(RegVal.Register = findRegisterByName(Parts[0].trim()))) {
	errs() << "unknown register '" << Parts[0]
	<< "' in 'LLVM-EXEGESIS-DEFREG " << CommentText << "'\n";
	++InvalidComments;
	return;
	}
	const StringRef HexValue = Parts[1].trim();
	RegVal.Value = APInt(
	/* each hex digit is 4 bits / HexValue.size() 4, HexValue, 16);
	Result->Key.RegisterInitialValues.push_back(std::move(RegVal));
	return;
	}
	if (CommentText.consume_front("LIVEIN")) {
	// LLVM-EXEGESIS-LIVEIN <reg>
	const auto RegName = CommentText.ltrim();
	if (unsigned Reg = findRegisterByName(RegName))
	Result->LiveIns.push_back(Reg);
	else {
	errs() << "unknown register '" << RegName
	<< "' in 'LLVM-EXEGESIS-LIVEIN " << CommentText << "'\n";
	++InvalidComments;
	}
	return;
	}
	if (CommentText.consume_front("MEM-DEF")) {
	// LLVM-EXEGESIS-MEM-DEF <name> <size> <value>
	SmallVector<StringRef, 3> Parts;
	CommentText.split(Parts, ' ', -1, false);
	if (Parts.size() != 3) {
	errs() << "invalid comment 'LLVM-EXEGESIS-MEM-DEF " << CommentText
	<< "', expected three parameters <NAME> <SIZE> <VALUE>";
	++InvalidComments;
	return;
	}
	const StringRef HexValue = Parts[2].trim();
	MemoryValue MemVal;
	MemVal.SizeBytes = std::stol(Parts[1].trim().str());
	if (HexValue.size() % 2 != 0) {
	errs() << "invalid comment 'LLVM-EXEGESIS-MEM-DEF " << CommentText
	<< "', expected <VALUE> to contain a whole number of bytes";
	}
	MemVal.Value = APInt(HexValue.size() * 4, HexValue, 16);
	MemVal.Index = Result->Key.MemoryValues.size();
	Result->Key.MemoryValues[Parts[0].trim().str()] = MemVal;
	return;
	}
	if (CommentText.consume_front("MEM-MAP")) {
	// LLVM-EXEGESIS-MEM-MAP <value name> <address>
	SmallVector<StringRef, 2> Parts;
	CommentText.split(Parts, ' ', -1, false);
	if (Parts.size() != 2) {
	errs() << "invalid comment 'LLVM-EXEGESIS-MEM-MAP " << CommentText
	<< "', expected two parameters <VALUE NAME> <ADDRESS>";
	++InvalidComments;
	return;
	}
	MemoryMapping MemMap;
	MemMap.MemoryValueName = Parts[0].trim().str();
	MemMap.Address = std::stol(Parts[1].trim().str());

	#ifdef __linux__
	// Validate that the annotation is a multiple of the platform's page
	// size.
	if (MemMap.Address % getpagesize() != 0) {
	errs() << "invalid comment 'LLVM-EXEGESIS-MEM-MAP " << CommentText
	<< "', expected <ADDRESS> to be a multiple of the platform page "
	"size.";
	++InvalidComments;
	return;
	}
	#endif // __linux__

	// validate that the annotation refers to an already existing memory
	// definition
	auto MemValIT = Result->Key.MemoryValues.find(Parts[0].trim().str());
	if (MemValIT == Result->Key.MemoryValues.end()) {
	errs() << "invalid comment 'LLVM-EXEGESIS-MEM-MAP " << CommentText
	<< "', expected <VALUE NAME> to contain the name of an already "
	"specified memory definition";
	++InvalidComments;
	return;
	}
	Result->Key.MemoryMappings.push_back(std::move(MemMap));
	return;
	}
	if (CommentText.consume_front("SNIPPET-ADDRESS")) {
	// LLVM-EXEGESIS-SNIPPET-ADDRESS <address>
	if (!to_integer<intptr_t>(CommentText.trim(), Result->Key.SnippetAddress,
	16)) {
	errs() << "invalid comment 'LLVM-EXEGESIS-SNIPPET-ADDRESS "
	<< CommentText
	<< "', expected <ADDRESS> to contain a valid integer in "
	"hexadecimal format";
	++InvalidComments;
	return;
	}

	#ifdef __linux__
	// Validate that the address in the annotation is a multiple of the
	// platform's page size.
	if (Result->Key.SnippetAddress % getpagesize() != 0) {
	errs() << "invalid comment 'LLVM-EXEGESIS-SNIPPET-ADDRESS "
	<< CommentText
	<< ", expected <ADDRESS> to be a multiple of the platform page "
	"size.";
	++InvalidComments;
	return;
	}
	#endif // __linux__

	return;
	}
	if (CommentText.consume_front("LOOP-REGISTER")) {
	// LLVM-EXEGESIS-LOOP-REGISTER <loop register>
	unsigned LoopRegister;

	if (!(LoopRegister = findRegisterByName(CommentText.trim()))) {
	errs() << "unknown register '" << CommentText
	<< "' in 'LLVM-EXEGESIS-LOOP-REGISTER " << CommentText << "'\n";
	++InvalidComments;
	return;
	}

	Result->Key.LoopRegister = LoopRegister;
	return;
	}
	}

	unsigned numInvalidComments() const { return InvalidComments; }

	private:
	// We only care about instructions, we don't implement this part of the API.
	void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
	Align ByteAlignment) override {}
	bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
	return false;
	}
	void emitValueToAlignment(Align Alignment, int64_t Value, unsigned ValueSize,
	unsigned MaxBytesToEmit) override {}
	void emitZerofill(MCSection Section, MCSymbol Symbol, uint64_t Size,
	Align ByteAlignment, SMLoc Loc) override {}

	unsigned findRegisterByName(const StringRef RegName) const {
	auto Iter = RegNameToRegNo.find(RegName);
	if (Iter != RegNameToRegNo.end())
	return Iter->second;
	errs() << "'" << RegName
	<< "' is not a valid register name for the target\n";
	return 0;
	}

	const DenseMap<StringRef, unsigned> &RegNameToRegNo;
	BenchmarkCode *const Result;
	unsigned InvalidComments = 0;
	};

	} // namespace

	// Reads code snippets from file `Filename`.
	Expected<std::vector<BenchmarkCode>> readSnippets(const LLVMState &State,
	StringRef Filename) {
	ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
	MemoryBuffer::getFileOrSTDIN(Filename);
	if (std::error_code EC = BufferPtr.getError()) {
	return make_error<Failure>("cannot read snippet: " + Filename + ": " +
	EC.message());
	}
	SourceMgr SM;
	SM.AddNewSourceBuffer(std::move(BufferPtr.get()), SMLoc());

	BenchmarkCode Result;

	// Ensure that there is a default loop register value specified.
	Result.Key.LoopRegister =
	State.getExegesisTarget().getDefaultLoopCounterRegister(
	State.getTargetMachine().getTargetTriple());

	const TargetMachine &TM = State.getTargetMachine();
	MCContext Context(TM.getTargetTriple(), TM.getMCAsmInfo(),
	TM.getMCRegisterInfo(), TM.getMCSubtargetInfo());
	std::unique_ptr<MCObjectFileInfo> ObjectFileInfo(
	TM.getTarget().createMCObjectFileInfo(Context, /PIC=/false));
	Context.setObjectFileInfo(ObjectFileInfo.get());
	Context.initInlineSourceManager();
	BenchmarkCodeStreamer Streamer(&Context, State.getRegNameToRegNoMapping(),
	&Result);

	std::string Error;
	raw_string_ostream ErrorStream(Error);
	formatted_raw_ostream InstPrinterOStream(ErrorStream);
	const std::unique_ptr<MCInstPrinter> InstPrinter(
	TM.getTarget().createMCInstPrinter(
	TM.getTargetTriple(), TM.getMCAsmInfo()->getAssemblerDialect(),
	TM.getMCAsmInfo(), TM.getMCInstrInfo(), *TM.getMCRegisterInfo()));
	// The following call will take care of calling Streamer.setTargetStreamer.
	TM.getTarget().createAsmTargetStreamer(Streamer, InstPrinterOStream,
	InstPrinter.get(),
	TM.Options.MCOptions.AsmVerbose);
	if (!Streamer.getTargetStreamer())
	return make_error<Failure>("cannot create target asm streamer");

	const std::unique_ptr<MCAsmParser> AsmParser(
	createMCAsmParser(SM, Context, Streamer, *TM.getMCAsmInfo()));
	if (!AsmParser)
	return make_error<Failure>("cannot create asm parser");
	AsmParser->getLexer().setCommentConsumer(&Streamer);

	const std::unique_ptr<MCTargetAsmParser> TargetAsmParser(
	TM.getTarget().createMCAsmParser(TM.getMCSubtargetInfo(), AsmParser,
	*TM.getMCInstrInfo(),
	MCTargetOptions()));

	if (!TargetAsmParser)
	return make_error<Failure>("cannot create target asm parser");
	AsmParser->setTargetParser(*TargetAsmParser);

	if (AsmParser->Run(false))
	return make_error<Failure>("cannot parse asm file");
	if (Streamer.numInvalidComments())
	return make_error<Failure>(Twine("found ")
	.concat(Twine(Streamer.numInvalidComments()))
	.concat(" invalid LLVM-EXEGESIS comments"));
	return std::vector<BenchmarkCode>{std::move(Result)};
	}

	} // namespace exegesis
	} // namespace llvm