[libc] Add global stdout and stderr objects.

[sivachandra]

Summary

They are added as entrypoint object targets. The header-gen
infrastructure has been extended to enable handling standard required
global objects. The libc-api-test has also been extended to verify the
global object declarations.

[lntue]

libc/utils/HdrGen/PublicAPICommand.cpp

119

const auto &Name?

[abrachet]

libc/src/__support/File/linux_file.cpp

169–170

These should probably be static

175

176

I don't know what values are ok for buffer_mode but stderr would logically have a different buffer mode from stdout because of no line buffering.

Why does stderr have OpenMode::WRITE and stdout has OpenMode::APPEND

[sivachandra]

Address comments.

[sivachandra]

Address one more comment missed in the previous update.

[sivachandra]

libc/src/__support/File/linux_file.cpp

169–170

Yes, fixed!

176

About buffering mode, we do not have line buffering support yet so I just left the value at 0. I have added a TODO to update that when we add line buffering support.

About WRITE vs APPEND, My intention was to put APPEND on both but I was playing with WRITE on one of them but forgot to put it back to APPEND. I have updated both to APPEND now.

Overall, this is a total case of copy-paste oversight. Sorry about that.

libc/config/linux/api.td

def StringAPI : PublicAPI<"string.h"> {
   let Types = ["size_t"];
 
   let Macros = [
     NullMacro,
   ];
 }
 
 def StdIOAPI : PublicAPI<"stdio.h"> {
+  let Macros = [
+    SimpleMacroDef<"stderr", "stderr">,
+    SimpleMacroDef<"stdout", "stdout">,
+  ];
   let Types = ["size_t", "FILE", "cookie_io_functions_t"];
 }
 
 def StdlibAPI : PublicAPI<"stdlib.h"> {
   let Types = [
     "div_t",
     "ldiv_t",
     "lldiv_t",

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.stdio.fread
     libc.src.stdio.fread_unlocked
     libc.src.stdio.fseek
     libc.src.stdio.funlockfile
     libc.src.stdio.fwrite
     libc.src.stdio.fwrite_unlocked
     libc.src.stdio.sprintf
     libc.src.stdio.snprintf
+    libc.src.stdio.stderr
+    libc.src.stdio.stdout
 
     # signal.h entrypoints
     # TODO: Enable signal.h entrypoints after fixing signal.h
     # libc.src.signal.raise
     # libc.src.signal.sigaction
     # libc.src.signal.sigdelset
     # libc.src.signal.sigaddset
     # libc.src.signal.sigemptyset

libc/config/public_api.td

 
 class PublicAPI<string name> {
   string HeaderName = name;
   list<MacroDef> Macros = [];
   list<string> Types = [];
   list<string> Enumerations = [];
   list<string> Structs = [];
   list<string> Functions = [];
+  list<string> Objects = [];
 }

libc/spec/spec.td

 }
 
 class FunctionSpec<string name, RetValSpec return, list<ArgSpec> args> {
   string Name = name;
   RetValSpec Return = return;
   list<ArgSpec> Args = args;
 }
 
+class ObjectSpec<string name, string type> {
+  string Name = name;
+  string Type = type;
+}
+
 class HeaderSpec<string name,
                 list<Macro> macros = [],
                 list<Type> types = [],
                 list<EnumeratedNameValue> enumerations = [],
-                list<FunctionSpec> functions = []> {
+                list<FunctionSpec> functions = [],
+                list<ObjectSpec> objects = []> {
   string Name = name;
   list<FunctionSpec> Functions = functions;
   list<Type> Types = types;
   list<Macro> Macros = macros;
   list<EnumeratedNameValue> Enumerations = enumerations;
+  list<ObjectSpec> Objects = objects;
 }
 
 class StandardSpec<string name> {
   string Name = name;
   list<HeaderSpec> Headers;
 }

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
           FunctionSpec<"nextafterf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>]>,
           FunctionSpec<"nextafter", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoubleType>]>,
           FunctionSpec<"nextafterl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<LongDoubleType>]>,
       ]
   >;
 
   HeaderSpec StdIO = HeaderSpec<
       "stdio.h",
-      [], // Macros
+      [
+          Macro<"stderr">,
+          Macro<"stdout">,
+      ], // Macros
       [ // Types
           SizeTType,
           FILE,
       ],
       [], // Enumerations
       [
           FunctionSpec<
               "clearerr",
HeaderSpec StdIO = HeaderSpec<
           >,
           FunctionSpec<
               "fprintf",
               RetValSpec<IntType>,
               [ArgSpec<FILERestrictedPtr>,
                ArgSpec<ConstCharRestrictedPtr>,
                ArgSpec<VarArgType>]
           >,
+      ],
+      [
+          ObjectSpec<
+              "stdout",
+              "FILE *"
+          >,
+          ObjectSpec<
+              "stderr",
+              "FILE *"
+          >,
       ]
   >;
 
   HeaderSpec StdLib = HeaderSpec<
       "stdlib.h",
       [], // Macros
       [
           DivTType,

libc/src/__support/File/file.h

public:
   // OpenMode, ContentType and CreateType.
   static ModeFlags mode_flags(const char *mode);
 };
 
 // The implementaiton of this function is provided by the platfrom_file
 // library.
 File *openfile(const char *path, const char *mode);
 
+extern File *stdout;
+extern File *stderr;
+
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H

libc/src/__support/File/linux_file.cpp

#endif
   auto *file = reinterpret_cast<LinuxFile *>(malloc(sizeof(LinuxFile)));
   LinuxFile::init(
       file, fd, buffer, File::DEFAULT_BUFFER_SIZE,
       0, // TODO: Set the correct buffer mode when buffer mode is available.
       true, modeflags);
   return file;
 }
 
+// TODO: Use the appropriate buffering modes for the standard streams below
+// the different buffering modes are available.
+constexpr size_t STDOUT_BUFFER_SIZE = 1024;
+char stdout_buffer[STDOUT_BUFFER_SIZE];
+static LinuxFile StdOut(1, stdout_buffer, STDOUT_BUFFER_SIZE, 0, false,
+                        File::ModeFlags(File::OpenMode::APPEND));
+File *stdout = &StdOut;
+
+constexpr size_t STDERR_BUFFER_SIZE = 1024;
+char stderr_buffer[STDERR_BUFFER_SIZE];
+static LinuxFile StdErr(2, stderr_buffer, STDERR_BUFFER_SIZE, 0, false,
+                        File::ModeFlags(File::OpenMode::APPEND));
+File *stderr = &StdErr;
+
 } // namespace __llvm_libc

libc/src/stdio/CMakeLists.txt

SRCS
     fopencookie.cpp
   HDRS
     fopencookie.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
 )
 
+add_entrypoint_object(
+  stdout
+  SRCS
+    stdout.cpp
+  HDRS
+    stdout.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
+
+add_entrypoint_object(
+  stderr
+  SRCS
+    stderr.cpp
+  HDRS
+    stderr.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
 
 add_entrypoint_object(
   sprintf
   SRCS
     sprintf.cpp
   HDRS
     sprintf.h
   DEPENDS

libc/src/stdio/stderr.h

+//===------------------------------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#error "Do not include this file. Instead include __support/File/file.h."

libc/src/stdio/stderr.cpp

+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+extern FILE *stderr = reinterpret_cast<FILE *>(__llvm_libc::stderr);

libc/src/stdio/stdout.h

+//===------------------------------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#error "Do not include this file. Instead include __support/File/file.h."

libc/src/stdio/stdout.cpp

+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+extern FILE *stdout = reinterpret_cast<FILE *>(__llvm_libc::stdout);

libc/test/src/CMakeLists.txt

 )
 # Blank out default include directories to prevent accidentally including
 # system headers or our own internal headers.
 set_target_properties(
   libc-api-test
   PROPERTIES
   INCLUDE_DIRECTORIES ""
 )
+target_link_libraries(libc-api-test llvmlibc)
+
 # Only include we need is the include for cpp::IsSame and our generated
 # public headers.
 target_include_directories(
   libc-api-test BEFORE
   PRIVATE
     "${LIBC_SOURCE_DIR}/src/__support/CPP"
     "${LIBC_BUILD_DIR}/include"
 )

libc/test/src/__support/File/platform_file_test.cpp

TEST(LlvmLibcPlatformFileTest, IncorrectOperation) {
 
   file = __llvm_libc::openfile(FILENAME, "a");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->read(data, 1), size_t(0)); // Cannot read
   ASSERT_FALSE(file->iseof());
   ASSERT_TRUE(file->error());
   ASSERT_EQ(file->close(), 0);
 }
+
+TEST(LlvmLibcPlatformFileTest, StdOutStdErrSmokeTest) {
+  EXPECT_FALSE(__llvm_libc::stdout == nullptr);
+  EXPECT_FALSE(__llvm_libc::stderr == nullptr);
+}

libc/utils/HdrGen/PrototypeTestGen/PrototypeTestGen.cpp

 
 bool TestGeneratorMain(llvm::raw_ostream &OS, llvm::RecordKeeper &records) {
   OS << "#include \"TypeTraits.h\"\n";
   llvm_libc::APIIndexer G(records);
   std::unordered_set<std::string> headerFileSet;
   for (const auto &entrypoint : EntrypointNamesOption) {
     auto match = G.FunctionToHeaderMap.find(entrypoint);
     if (match == G.FunctionToHeaderMap.end()) {
+      auto objectMatch = G.ObjectToHeaderMap.find(entrypoint);
+      if (objectMatch != G.ObjectToHeaderMap.end()) {
+        headerFileSet.insert(objectMatch->second);
+        continue;
+      }
+
       llvm::errs() << "ERROR: entrypoint '" << entrypoint
                    << "' could not be found in spec in any public header\n";
       return true;
     }
     headerFileSet.insert(match->second);
   }
   for (const auto &header : headerFileSet)
     OS << "#include <" << header << ">\n";
 
   OS << '\n';
 
   OS << "int main() {\n";
   for (const auto &entrypoint : EntrypointNamesOption) {
     auto match = G.FunctionSpecMap.find(entrypoint);
     if (match == G.FunctionSpecMap.end()) {
+      auto objectMatch = G.ObjectSpecMap.find(entrypoint);
+      if (objectMatch != G.ObjectSpecMap.end()) {
+        auto entrypointPtr = entrypoint + "_ptr";
+        llvm::Record *objectSpec = G.ObjectSpecMap[entrypoint];
+        auto objectType = objectSpec->getValueAsString("Type");
+        // We just make sure that the global object is present.
+        OS << "  " << objectType << " *" << entrypointPtr << " = &"
+           << entrypoint << ";\n";
+        OS << "  ++" << entrypointPtr << ";\n"; // To avoid unused var warning.
+        continue;
+      }
       llvm::errs() << "ERROR: entrypoint '" << entrypoint
                    << "' could not be found in spec in any public header\n";
       return true;
     }
     llvm::Record *functionSpec = match->second;
     llvm::Record *retValSpec = functionSpec->getValueAsDef("Return");
     std::string returnType =
         G.getTypeAsString(retValSpec->getValueAsDef("ReturnType"));
OS << '"' << entrypoint
        << " prototype in TableGen does not match public header" << '"';
     OS << ");\n";
   }
 
   OS << '\n';
   OS << "  return 0;\n";
   OS << "}\n\n";
 
+  // We provide dummy malloc and free implementations to support the case
+  // when LLVM libc does to include them.
+  OS << "void *malloc(size_t) { return nullptr; }\n";
+  OS << "void free(void *) {}\n";
+
   return false;
 }
 
 int main(int argc, char *argv[]) {
   llvm::cl::ParseCommandLineOptions(argc, argv);
   return TableGenMain(argv[0], TestGeneratorMain);
 }

libc/utils/HdrGen/PublicAPICommand.cpp

for (size_t i = 0; i < ArgsList.size(); ++i) {
       llvm::Record *ArgType = ArgsList[i]->getValueAsDef("ArgType");
       OS << G.getTypeAsString(ArgType);
       if (i < ArgsList.size() - 1)
         OS << ", ";
     }
 
     OS << ");\n\n";
   }
+
+  // Make another pass over entrypoints to emit object declarations.
+  for (const auto &Name : EntrypointNameList) {
+    if (G.ObjectSpecMap.find(Name) == G.ObjectSpecMap.end())
+      continue;
+    llvm::Record *ObjectSpec = G.ObjectSpecMap[Name];
+    auto Type = ObjectSpec->getValueAsString("Type");
+    OS << "extern " << Type << " " << Name << ";\n";
+  }
   OS << "__END_C_DECLS\n";
 }
 
 void writePublicAPI(llvm::raw_ostream &OS, llvm::RecordKeeper &Records) {}
 
 const char PublicAPICommand::Name[] = "public_api";
 
 void PublicAPICommand::run(llvm::raw_ostream &OS, const ArgVector &Args,

libc/utils/LibcTableGenUtil/APIIndexer.h

public:
   }
 
   // Mapping from names to records defining them.
   NameToRecordMapping MacroSpecMap;
   NameToRecordMapping TypeSpecMap;
   NameToRecordMapping EnumerationSpecMap;
   NameToRecordMapping FunctionSpecMap;
   NameToRecordMapping MacroDefsMap;
+  NameToRecordMapping ObjectSpecMap;
 
   std::unordered_map<std::string, std::string> FunctionToHeaderMap;
+  std::unordered_map<std::string, std::string> ObjectToHeaderMap;
 
   NameSet RequiredTypes;
   NameSet Structs;
   NameSet Enumerations;
   NameSet Functions;
+  NameSet Objects;
   NameSet PublicHeaders;
 
   std::string getTypeAsString(llvm::Record *TypeRecord);
 };
 
 } // namespace llvm_libc
 
 #endif // LLVM_LIBC_UTILS_LIBC_TABLE_GEN_UTILS_API_INDEXER_H

libc/utils/LibcTableGenUtil/APIIndexer.cpp

if (!StdHeader.hasValue() || Header == StdHeader) {
       }
 
       auto EnumerationSpecList =
           HeaderSpec->getValueAsListOfDefs("Enumerations");
       for (llvm::Record *EnumerationSpec : EnumerationSpecList) {
         EnumerationSpecMap[std::string(
             EnumerationSpec->getValueAsString("Name"))] = EnumerationSpec;
       }
+
+      auto ObjectSpecList = HeaderSpec->getValueAsListOfDefs("Objects");
+      for (llvm::Record *ObjectSpec : ObjectSpecList) {
+        auto ObjectName = std::string(ObjectSpec->getValueAsString("Name"));
+        ObjectSpecMap[ObjectName] = ObjectSpec;
+        ObjectToHeaderMap[ObjectName] = std::string(Header);
+      }
     }
   }
 }
 
 void APIIndexer::indexPublicAPIDef(llvm::Record *PublicAPI) {
   // While indexing the public API, we do not check if any of the entities
   // requested is from an included standard. Such a check is done while
   // generating the API.
void APIIndexer::indexPublicAPIDef(llvm::Record *PublicAPI) {
 
   auto FunctionList = PublicAPI->getValueAsListOfStrings("Functions");
   for (llvm::StringRef FunctionName : FunctionList)
     Functions.insert(std::string(FunctionName));
 
   auto EnumerationList = PublicAPI->getValueAsListOfStrings("Enumerations");
   for (llvm::StringRef EnumerationName : EnumerationList)
     Enumerations.insert(std::string(EnumerationName));
+
+  auto ObjectList = PublicAPI->getValueAsListOfStrings("Objects");
+  for (llvm::StringRef ObjectName : ObjectList)
+    Objects.insert(std::string(ObjectName));
 }
 
 void APIIndexer::index(llvm::RecordKeeper &Records) {
   NamedTypeClass = Records.getClass(NamedTypeClassName);
   PtrTypeClass = Records.getClass(PtrTypeClassName);
   RestrictedPtrTypeClass = Records.getClass(RestrictedPtrTypeClassName);
   StructClass = Records.getClass(StructTypeClassName);
   ConstTypeClass = Records.getClass(ConstTypeClassName);