This is an archive of the discontinued LLVM Phabricator instance.

Differential D85660

[flang][msvc] Use platform-independent primitives in temporary f18 driver.
ClosedPublic

Authored by Meinersbur on Aug 10 2020, 9:34 AM.

Details

Reviewers
isuruf
DavidTruby
sscalpone
klausler
tskeith
jdoerfert
Commits
rG18e9482e44ed: [flang][msvc] Use platform-independent primitives in temporary f18 driver.
Summary

Use functions for process launching, temporary file creation and file deletion from LLVM support library instead of POSIX-specific ones.

This patch is part of the series to make flang compilable with MS Visual Studio.

Diff Detail

Event Timeline

Meinersbur created this revision.Aug 10 2020, 9:34 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptAug 10 2020, 9:34 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added a subscriber: llvm-commits. · View Herald Transcript
Meinersbur requested review of this revision.Aug 10 2020, 9:34 AM
Harbormaster completed remote builds in B67739: Diff 284405.Aug 10 2020, 9:35 AM
Meinersbur updated this revision to Diff 284415.Aug 10 2020, 9:48 AM
  • Use llvm::report_fatal_error
Harbormaster completed remote builds in B67744: Diff 284415.Aug 10 2020, 9:53 AM
DavidTruby accepted this revision.Aug 11 2020, 5:15 AM

LGTM! I wonder why we have all this duplicated code here though...

This revision is now accepted and ready to land.Aug 11 2020, 5:15 AM
This revision was landed with ongoing or failed builds.Aug 13 2020, 12:17 AM
Closed by commit rG18e9482e44ed: [flang][msvc] Use platform-independent primitives in temporary f18 driver. (authored by Meinersbur). · Explain Why
This revision was automatically updated to reflect the committed changes.
Meinersbur added a commit: rG18e9482e44ed: [flang][msvc] Use platform-independent primitives in temporary f18 driver..

Revision Contents

PathSize
flang/
tools/
f18-parse-demo/
97 lines
f18/
105 lines

Diff 284415

flang/tools/f18-parse-demo/f18-parse-demo.cpp

//===-- tools/f18/f18-parse-demo.cpp --------------------------------------===// //===-- tools/f18/f18-parse-demo.cpp --------------------------------------===//
Lint: Lint
Inline Actions

clang-format not found in user's PATH; not linting file.

Lint: Lint: clang-format not found in user's PATH; not linting file.
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 19 Lines
#include "flang/Parser/message.h" #include "flang/Parser/message.h"
#include "flang/Parser/parse-tree-visitor.h" #include "flang/Parser/parse-tree-visitor.h"
#include "flang/Parser/parse-tree.h" #include "flang/Parser/parse-tree.h"
#include "flang/Parser/parsing.h" #include "flang/Parser/parsing.h"
#include "flang/Parser/provenance.h" #include "flang/Parser/provenance.h"
#include "flang/Parser/unparse.h" #include "flang/Parser/unparse.h"
#include "llvm/Support/Errno.h" #include "llvm/Support/Errno.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/Program.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <cstdio> #include <cstdio>
#include <cstring> #include <cstring>
#include <fstream> #include <fstream>
#include <list> #include <list>
#include <memory> #include <memory>
#include <optional> #include <optional>
#include <stdlib.h> #include <stdlib.h>
#include <string> #include <string>
#include <sys/wait.h>
#include <time.h> #include <time.h>
#include <unistd.h>
#include <vector> #include <vector>
static std::list<std::string> argList(int argc, char *const argv[]) { static std::list<std::string> argList(int argc, char *const argv[]) {
std::list<std::string> result; std::list<std::string> result;
for (int j = 0; j < argc; ++j) { for (int j = 0; j < argc; ++j) {
result.emplace_back(argv[j]); result.emplace_back(argv[j]);
} }
return result; return result;
Show All 37 Linesstruct DriverOptions {
bool dumpCookedChars{false}; bool dumpCookedChars{false};
bool dumpUnparse{false}; bool dumpUnparse{false};
bool dumpParseTree{false}; bool dumpParseTree{false};
bool timeParse{false}; bool timeParse{false};
std::vector<std::string> fcArgs; std::vector<std::string> fcArgs;
const char *prefix{nullptr}; const char *prefix{nullptr};
}; };
bool ParentProcess() { void Exec(std::vector<llvm::StringRef> &argv, bool verbose = false) {
if (fork() == 0) {
return false; // in child process
}
int childStat{0};
wait(&childStat);
if (!WIFEXITED(childStat) || WEXITSTATUS(childStat) != 0) {
exit(EXIT_FAILURE);
}
return true;
}
void Exec(std::vector<char *> &argv, bool verbose = false) {
if (verbose) { if (verbose) {
for (size_t j{0}; j < argv.size(); ++j) { for (size_t j{0}; j < argv.size(); ++j) {
llvm::errs() << (j > 0 ? " " : "") << argv[j]; llvm::errs() << (j > 0 ? " " : "") << argv[j];
} }
llvm::errs() << '\n'; llvm::errs() << '\n';
} }
argv.push_back(nullptr); std::string ErrMsg;
execvp(argv[0], &argv[0]); if (llvm::sys::ExecuteAndWait(argv[0], llvm::makeArrayRef(argv).slice(1),
llvm::errs() << "execvp(" << argv[0] llvm::None, {}, 0, 0, &ErrMsg))
<< ") failed: " << llvm::sys::StrError(errno) << '\n'; llvm::report_fatal_error(
exit(EXIT_FAILURE); llvm::Twine("execvp(") + argv[0] + ") failed: " + ErrMsg);
} }
void RunOtherCompiler(DriverOptions &driver, char *source, char *relo) { void RunOtherCompiler(DriverOptions &driver, char *source, char *relo) {
std::vector<char *> argv; std::vector<llvm::StringRef> argv;
for (size_t j{0}; j < driver.fcArgs.size(); ++j) { for (size_t j{0}; j < driver.fcArgs.size(); ++j) {
argv.push_back(driver.fcArgs[j].data()); argv.push_back(driver.fcArgs[j]);
} }
char dashC[3] = "-c", dashO[3] = "-o"; char dashC[3] = "-c", dashO[3] = "-o";
argv.push_back(dashC); argv.push_back(dashC);
argv.push_back(dashO); argv.push_back(dashO);
argv.push_back(relo); argv.push_back(relo);
argv.push_back(source); argv.push_back(source);
Exec(argv, driver.verbose); Exec(argv, driver.verbose);
} }
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines if (driver.dumpUnparse) {
return {}; return {};
} }
if (driver.parseOnly) { if (driver.parseOnly) {
return {}; return {};
} }
std::string relo{RelocatableName(driver, path)}; std::string relo{RelocatableName(driver, path)};
char tmpSourcePath[32]; llvm::SmallString<32> tmpSourcePath;
std::snprintf(tmpSourcePath, sizeof tmpSourcePath, "/tmp/f18-%lx.f90",
static_cast<unsigned long>(getpid()));
{ {
std::error_code EC; int fd;
llvm::raw_fd_ostream tmpSource(tmpSourcePath, EC, llvm::sys::fs::F_None); std::error_code EC =
if (EC) { llvm::sys::fs::createUniqueFile("f18-%%%%.f90", fd, tmpSourcePath);
llvm::errs() << EC.message(); if (EC)
std::exit(EXIT_FAILURE); llvm::report_fatal_error(EC.message());
} llvm::raw_fd_ostream tmpSource(fd, /*shouldClose*/ true);
Unparse(tmpSource, parseTree, driver.encoding, true /*capitalize*/, Unparse(tmpSource, parseTree, driver.encoding, true /*capitalize*/,
options.features.IsEnabled( options.features.IsEnabled(
Fortran::common::LanguageFeature::BackslashEscapes)); Fortran::common::LanguageFeature::BackslashEscapes));
} }
if (ParentProcess()) { RunOtherCompiler(driver, tmpSourcePath.data(), relo.data());
filesToDelete.push_back(tmpSourcePath); filesToDelete.emplace_back(tmpSourcePath);
if (!driver.compileOnly && driver.outputPath.empty()) { if (!driver.compileOnly && driver.outputPath.empty()) {
filesToDelete.push_back(relo); filesToDelete.push_back(relo);
} }
return relo; return relo;
} }
RunOtherCompiler(driver, tmpSourcePath, relo.data());
return {};
}
std::string CompileOtherLanguage(std::string path, DriverOptions &driver) { std::string CompileOtherLanguage(std::string path, DriverOptions &driver) {
std::string relo{RelocatableName(driver, path)}; std::string relo{RelocatableName(driver, path)};
if (ParentProcess()) { RunOtherCompiler(driver, path.data(), relo.data());
if (!driver.compileOnly && driver.outputPath.empty()) { if (!driver.compileOnly && driver.outputPath.empty()) {
filesToDelete.push_back(relo); filesToDelete.push_back(relo);
} }
return relo; return relo;
} }
RunOtherCompiler(driver, path.data(), relo.data());
return {};
}
void Link(std::vector<std::string> &relocatables, DriverOptions &driver) { void Link(std::vector<std::string> &relocatables, DriverOptions &driver) {
if (!ParentProcess()) { std::vector<llvm::StringRef> argv;
std::vector<char *> argv;
for (size_t j{0}; j < driver.fcArgs.size(); ++j) { for (size_t j{0}; j < driver.fcArgs.size(); ++j) {
argv.push_back(driver.fcArgs[j].data()); argv.push_back(driver.fcArgs[j].data());
} }
for (auto &relo : relocatables) { for (auto &relo : relocatables) {
argv.push_back(relo.data()); argv.push_back(relo.data());
} }
if (!driver.outputPath.empty()) { if (!driver.outputPath.empty()) {
char dashO[3] = "-o"; char dashO[3] = "-o";
argv.push_back(dashO); argv.push_back(dashO);
argv.push_back(driver.outputPath.data()); argv.push_back(driver.outputPath.data());
} }
Exec(argv, driver.verbose); Exec(argv, driver.verbose);
} }
}
int main(int argc, char *const argv[]) { int main(int argc, char *const argv[]) {
atexit(CleanUpAtExit); atexit(CleanUpAtExit);
DriverOptions driver; DriverOptions driver;
const char *fc{getenv("F18_FC")}; const char *fc{getenv("F18_FC")};
driver.fcArgs.push_back(fc ? fc : "gfortran"); driver.fcArgs.push_back(fc ? fc : "gfortran");
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

flang/tools/f18/f18.cpp

//===-- tools/f18/f18.cpp -------------------------------------------------===// //===-- tools/f18/f18.cpp -------------------------------------------------===//
Lint: Lint
Inline Actions

clang-format not found in user's PATH; not linting file.

Lint: Lint: clang-format not found in user's PATH; not linting file.
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 11 Lines
#include "flang/Parser/parsing.h" #include "flang/Parser/parsing.h"
#include "flang/Parser/provenance.h" #include "flang/Parser/provenance.h"
#include "flang/Parser/unparse.h" #include "flang/Parser/unparse.h"
#include "flang/Semantics/expression.h" #include "flang/Semantics/expression.h"
#include "flang/Semantics/semantics.h" #include "flang/Semantics/semantics.h"
#include "flang/Semantics/unparse-with-symbols.h" #include "flang/Semantics/unparse-with-symbols.h"
#include "llvm/Support/Errno.h" #include "llvm/Support/Errno.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/Program.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <cstdio> #include <cstdio>
#include <cstring> #include <cstring>
#include <fstream> #include <fstream>
#include <list> #include <list>
#include <memory> #include <memory>
#include <optional> #include <optional>
#include <stdlib.h> #include <stdlib.h>
#include <string> #include <string>
#include <sys/wait.h>
#include <unistd.h>
#include <vector> #include <vector>
static std::list<std::string> argList(int argc, char *const argv[]) { static std::list<std::string> argList(int argc, char *const argv[]) {
std::list<std::string> result; std::list<std::string> result;
for (int j = 0; j < argc; ++j) { for (int j = 0; j < argc; ++j) {
result.emplace_back(argv[j]); result.emplace_back(argv[j]);
} }
return result; return result;
Show All 16 Lines llvm::outs() << "Parse tree comprises " << visitor.objects
<< " total bytes.\n"; << " total bytes.\n";
} }
std::vector<std::string> filesToDelete; std::vector<std::string> filesToDelete;
void CleanUpAtExit() { void CleanUpAtExit() {
for (const auto &path : filesToDelete) { for (const auto &path : filesToDelete) {
if (!path.empty()) { if (!path.empty()) {
unlink(path.data()); llvm::sys::fs::remove(path);
} }
} }
} }
struct GetDefinitionArgs { struct GetDefinitionArgs {
int line, startColumn, endColumn; int line, startColumn, endColumn;
}; };
Show All 25 Linesstruct DriverOptions {
bool unparseTypedExprsToF18_FC{false}; bool unparseTypedExprsToF18_FC{false};
std::vector<std::string> F18_FCArgs; std::vector<std::string> F18_FCArgs;
const char *prefix{nullptr}; const char *prefix{nullptr};
bool getDefinition{false}; bool getDefinition{false};
GetDefinitionArgs getDefinitionArgs{0, 0, 0}; GetDefinitionArgs getDefinitionArgs{0, 0, 0};
bool getSymbolsSources{false}; bool getSymbolsSources{false};
}; };
bool ParentProcess() { void Exec(std::vector<llvm::StringRef> &argv, bool verbose = false) {
if (fork() == 0) {
return false; // in child process
}
int childStat{0};
wait(&childStat);
if (!WIFEXITED(childStat) || WEXITSTATUS(childStat) != 0) {
exit(EXIT_FAILURE);
}
return true;
}
void Exec(std::vector<char *> &argv, bool verbose = false) {
if (verbose) { if (verbose) {
for (size_t j{0}; j < argv.size(); ++j) { for (size_t j{0}; j < argv.size(); ++j) {
llvm::errs() << (j > 0 ? " " : "") << argv[j]; llvm::errs() << (j > 0 ? " " : "") << argv[j];
} }
llvm::errs() << '\n'; llvm::errs() << '\n';
} }
argv.push_back(nullptr); std::string ErrMsg;
execvp(argv[0], &argv[0]); if (llvm::sys::ExecuteAndWait(argv[0], llvm::makeArrayRef(argv).slice(1),
llvm::errs() << "execvp(" << argv[0] llvm::None, {}, 0, 0, &ErrMsg))
<< ") failed: " << llvm::sys::StrError(errno) << '\n'; llvm::report_fatal_error(
exit(EXIT_FAILURE); llvm::Twine("execvp(") + argv[0] + ") failed: " + ErrMsg);
} }
void RunOtherCompiler(DriverOptions &driver, char *source, char *relo) { void RunOtherCompiler(DriverOptions &driver, char *source, char *relo) {
std::vector<char *> argv; std::vector<llvm::StringRef> argv;
for (size_t j{0}; j < driver.F18_FCArgs.size(); ++j) { for (size_t j{0}; j < driver.F18_FCArgs.size(); ++j) {
argv.push_back(driver.F18_FCArgs[j].data()); argv.push_back(driver.F18_FCArgs[j]);
} }
char dashC[3] = "-c", dashO[3] = "-o"; char dashC[3] = "-c", dashO[3] = "-o";
argv.push_back(dashC); argv.push_back(dashC);
argv.push_back(dashO); argv.push_back(dashO);
argv.push_back(relo); argv.push_back(relo);
argv.push_back(source); argv.push_back(source);
Exec(argv, driver.verbose); Exec(argv, driver.verbose);
} }
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines if (driver.dumpPreFirTree) {
} }
} }
if (driver.parseOnly) { if (driver.parseOnly) {
return {}; return {};
} }
std::string relo{RelocatableName(driver, path)}; std::string relo{RelocatableName(driver, path)};
char tmpSourcePath[32]; llvm::SmallString<32> tmpSourcePath;
std::snprintf(tmpSourcePath, sizeof tmpSourcePath, "/tmp/f18-%lx.f90",
static_cast<unsigned long>(getpid()));
{ {
std::error_code EC; int fd;
llvm::raw_fd_ostream tmpSource(tmpSourcePath, EC, llvm::sys::fs::F_None); std::error_code EC =
if (EC) { llvm::sys::fs::createUniqueFile("f18-%%%%.f90", fd, tmpSourcePath);
llvm::errs() << EC.message() << "\n"; if (EC)
std::exit(EXIT_FAILURE); llvm::report_fatal_error(EC.message());
} llvm::raw_fd_ostream tmpSource(fd, /*shouldClose*/ true);
Unparse(tmpSource, parseTree, driver.encoding, true /*capitalize*/, Unparse(tmpSource, parseTree, driver.encoding, true /*capitalize*/,
options.features.IsEnabled( options.features.IsEnabled(
Fortran::common::LanguageFeature::BackslashEscapes), Fortran::common::LanguageFeature::BackslashEscapes),
nullptr /* action before each statement */, nullptr /* action before each statement */,
driver.unparseTypedExprsToF18_FC ? &asFortran : nullptr); driver.unparseTypedExprsToF18_FC ? &asFortran : nullptr);
} }
if (ParentProcess()) { RunOtherCompiler(driver, tmpSourcePath.data(), relo.data());
filesToDelete.push_back(tmpSourcePath); filesToDelete.emplace_back(tmpSourcePath);
if (!driver.compileOnly && driver.outputPath.empty()) { if (!driver.compileOnly && driver.outputPath.empty()) {
filesToDelete.push_back(relo); filesToDelete.push_back(relo);
} }
return relo; return relo;
} }
RunOtherCompiler(driver, tmpSourcePath, relo.data());
return {};
}
std::string CompileOtherLanguage(std::string path, DriverOptions &driver) { std::string CompileOtherLanguage(std::string path, DriverOptions &driver) {
std::string relo{RelocatableName(driver, path)}; std::string relo{RelocatableName(driver, path)};
if (ParentProcess()) { RunOtherCompiler(driver, path.data(), relo.data());
if (!driver.compileOnly && driver.outputPath.empty()) { if (!driver.compileOnly && driver.outputPath.empty()) {
filesToDelete.push_back(relo); filesToDelete.push_back(relo);
} }
return relo; return relo;
} }
RunOtherCompiler(driver, path.data(), relo.data());
return {};
}
void Link(std::vector<std::string> &liblist, std::vector<std::string> &objects, void Link(std::vector<std::string> &liblist, std::vector<std::string> &objects,
DriverOptions &driver) { DriverOptions &driver) {
if (!ParentProcess()) { std::vector<llvm::StringRef> argv;
std::vector<char *> argv;
for (size_t j{0}; j < driver.F18_FCArgs.size(); ++j) { for (size_t j{0}; j < driver.F18_FCArgs.size(); ++j) {
argv.push_back(driver.F18_FCArgs[j].data()); argv.push_back(driver.F18_FCArgs[j].data());
} }
for (auto &obj : objects) { for (auto &obj : objects) {
argv.push_back(obj.data()); argv.push_back(obj.data());
} }
if (!driver.outputPath.empty()) { if (!driver.outputPath.empty()) {
char dashO[3] = "-o"; char dashO[3] = "-o";
argv.push_back(dashO); argv.push_back(dashO);
argv.push_back(driver.outputPath.data()); argv.push_back(driver.outputPath.data());
} }
for (auto &lib : liblist) { for (auto &lib : liblist) {
argv.push_back(lib.data()); argv.push_back(lib.data());
} }
Exec(argv, driver.verbose); Exec(argv, driver.verbose);
} }
}
int main(int argc, char *const argv[]) { int main(int argc, char *const argv[]) {
atexit(CleanUpAtExit); atexit(CleanUpAtExit);
DriverOptions driver; DriverOptions driver;
const char *F18_FC{getenv("F18_FC")}; const char *F18_FC{getenv("F18_FC")};
driver.F18_FCArgs.push_back(F18_FC ? F18_FC : "gfortran"); driver.F18_FCArgs.push_back(F18_FC ? F18_FC : "gfortran");
▲ Show 20 Lines • Show All 331 Lines • Show Last 20 Lines