From 0b57cec536236d46e3dba9bd041533462f33dbb7 Mon Sep 17 00:00:00 2001 From: Dimitry Andric Date: Fri, 20 Dec 2019 19:53:05 +0000 Subject: Move all sources from the llvm project into contrib/llvm-project. This uses the new layout of the upstream repository, which was recently migrated to GitHub, and converted into a "monorepo". That is, most of the earlier separate sub-projects with their own branches and tags were consolidated into one top-level directory, and are now branched and tagged together. Updating the vendor area to match this layout is next. --- contrib/llvm-project/llvm/lib/AsmParser/Parser.cpp | 186 +++++++++++++++++++++ 1 file changed, 186 insertions(+) create mode 100644 contrib/llvm-project/llvm/lib/AsmParser/Parser.cpp (limited to 'contrib/llvm-project/llvm/lib/AsmParser/Parser.cpp') diff --git a/contrib/llvm-project/llvm/lib/AsmParser/Parser.cpp b/contrib/llvm-project/llvm/lib/AsmParser/Parser.cpp new file mode 100644 index 000000000000..b13c6237f411 --- /dev/null +++ b/contrib/llvm-project/llvm/lib/AsmParser/Parser.cpp @@ -0,0 +1,186 @@ +//===- Parser.cpp - Main dispatch module for the Parser library -----------===// +// +// 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 +// +//===----------------------------------------------------------------------===// +// +// This library implements the functionality defined in llvm/AsmParser/Parser.h +// +//===----------------------------------------------------------------------===// + +#include "llvm/AsmParser/Parser.h" +#include "LLParser.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/IR/Module.h" +#include "llvm/IR/ModuleSummaryIndex.h" +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/Support/SourceMgr.h" +#include "llvm/Support/raw_ostream.h" +#include +#include +using namespace llvm; + +bool llvm::parseAssemblyInto(MemoryBufferRef F, Module *M, + ModuleSummaryIndex *Index, SMDiagnostic &Err, + SlotMapping *Slots, bool UpgradeDebugInfo, + StringRef DataLayoutString) { + SourceMgr SM; + std::unique_ptr Buf = MemoryBuffer::getMemBuffer(F); + SM.AddNewSourceBuffer(std::move(Buf), SMLoc()); + + LLVMContext Context; + return LLParser(F.getBuffer(), SM, Err, M, Index, + M ? M->getContext() : Context, Slots, UpgradeDebugInfo, + DataLayoutString) + .Run(); +} + +std::unique_ptr +llvm::parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context, + SlotMapping *Slots, bool UpgradeDebugInfo, + StringRef DataLayoutString) { + std::unique_ptr M = + make_unique(F.getBufferIdentifier(), Context); + + if (parseAssemblyInto(F, M.get(), nullptr, Err, Slots, UpgradeDebugInfo, + DataLayoutString)) + return nullptr; + + return M; +} + +std::unique_ptr +llvm::parseAssemblyFile(StringRef Filename, SMDiagnostic &Err, + LLVMContext &Context, SlotMapping *Slots, + bool UpgradeDebugInfo, StringRef DataLayoutString) { + ErrorOr> FileOrErr = + MemoryBuffer::getFileOrSTDIN(Filename); + if (std::error_code EC = FileOrErr.getError()) { + Err = SMDiagnostic(Filename, SourceMgr::DK_Error, + "Could not open input file: " + EC.message()); + return nullptr; + } + + return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context, Slots, + UpgradeDebugInfo, DataLayoutString); +} + +ParsedModuleAndIndex llvm::parseAssemblyWithIndex( + MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context, + SlotMapping *Slots, bool UpgradeDebugInfo, StringRef DataLayoutString) { + std::unique_ptr M = + make_unique(F.getBufferIdentifier(), Context); + std::unique_ptr Index = + make_unique(/*HaveGVs=*/true); + + if (parseAssemblyInto(F, M.get(), Index.get(), Err, Slots, UpgradeDebugInfo, + DataLayoutString)) + return {nullptr, nullptr}; + + return {std::move(M), std::move(Index)}; +} + +ParsedModuleAndIndex llvm::parseAssemblyFileWithIndex( + StringRef Filename, SMDiagnostic &Err, LLVMContext &Context, + SlotMapping *Slots, bool UpgradeDebugInfo, StringRef DataLayoutString) { + ErrorOr> FileOrErr = + MemoryBuffer::getFileOrSTDIN(Filename); + if (std::error_code EC = FileOrErr.getError()) { + Err = SMDiagnostic(Filename, SourceMgr::DK_Error, + "Could not open input file: " + EC.message()); + return {nullptr, nullptr}; + } + + return parseAssemblyWithIndex(FileOrErr.get()->getMemBufferRef(), Err, + Context, Slots, UpgradeDebugInfo, + DataLayoutString); +} + +std::unique_ptr +llvm::parseAssemblyString(StringRef AsmString, SMDiagnostic &Err, + LLVMContext &Context, SlotMapping *Slots, + bool UpgradeDebugInfo, StringRef DataLayoutString) { + MemoryBufferRef F(AsmString, ""); + return parseAssembly(F, Err, Context, Slots, UpgradeDebugInfo, + DataLayoutString); +} + +static bool parseSummaryIndexAssemblyInto(MemoryBufferRef F, + ModuleSummaryIndex &Index, + SMDiagnostic &Err) { + SourceMgr SM; + std::unique_ptr Buf = MemoryBuffer::getMemBuffer(F); + SM.AddNewSourceBuffer(std::move(Buf), SMLoc()); + + // The parser holds a reference to a context that is unused when parsing the + // index, but we need to initialize it. + LLVMContext unusedContext; + return LLParser(F.getBuffer(), SM, Err, nullptr, &Index, unusedContext).Run(); +} + +std::unique_ptr +llvm::parseSummaryIndexAssembly(MemoryBufferRef F, SMDiagnostic &Err) { + std::unique_ptr Index = + make_unique(/*HaveGVs=*/false); + + if (parseSummaryIndexAssemblyInto(F, *Index, Err)) + return nullptr; + + return Index; +} + +std::unique_ptr +llvm::parseSummaryIndexAssemblyFile(StringRef Filename, SMDiagnostic &Err) { + ErrorOr> FileOrErr = + MemoryBuffer::getFileOrSTDIN(Filename); + if (std::error_code EC = FileOrErr.getError()) { + Err = SMDiagnostic(Filename, SourceMgr::DK_Error, + "Could not open input file: " + EC.message()); + return nullptr; + } + + return parseSummaryIndexAssembly(FileOrErr.get()->getMemBufferRef(), Err); +} + +Constant *llvm::parseConstantValue(StringRef Asm, SMDiagnostic &Err, + const Module &M, const SlotMapping *Slots) { + SourceMgr SM; + std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Asm); + SM.AddNewSourceBuffer(std::move(Buf), SMLoc()); + Constant *C; + if (LLParser(Asm, SM, Err, const_cast(&M), nullptr, M.getContext()) + .parseStandaloneConstantValue(C, Slots)) + return nullptr; + return C; +} + +Type *llvm::parseType(StringRef Asm, SMDiagnostic &Err, const Module &M, + const SlotMapping *Slots) { + unsigned Read; + Type *Ty = parseTypeAtBeginning(Asm, Read, Err, M, Slots); + if (!Ty) + return nullptr; + if (Read != Asm.size()) { + SourceMgr SM; + std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Asm); + SM.AddNewSourceBuffer(std::move(Buf), SMLoc()); + Err = SM.GetMessage(SMLoc::getFromPointer(Asm.begin() + Read), + SourceMgr::DK_Error, "expected end of string"); + return nullptr; + } + return Ty; +} +Type *llvm::parseTypeAtBeginning(StringRef Asm, unsigned &Read, + SMDiagnostic &Err, const Module &M, + const SlotMapping *Slots) { + SourceMgr SM; + std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Asm); + SM.AddNewSourceBuffer(std::move(Buf), SMLoc()); + Type *Ty; + if (LLParser(Asm, SM, Err, const_cast(&M), nullptr, M.getContext()) + .parseTypeAtBeginning(Ty, Read, Slots)) + return nullptr; + return Ty; +} -- cgit v1.2.3