Clean up use of C allocation functions

[sepavloff]

Summary

This change cleans up uses of malloc/calloc/realloc. In the case where
the return value is not checked agains null pointer, the call to
'std::malloc' is replaced by 'llvm::malloc', which reports fatal error
on allocation failure. In plain C files, assertion statements are added
to ensure that memory is successfully allocated.

The aim of this change is to get better diagnostics of OOM on Windows.

[rnk]

lgtm

cfe/trunk/include/clang/Sema/ParsedTemplate.h

struct TemplateIdAnnotation final
     static TemplateIdAnnotation *
     Create(CXXScopeSpec SS, SourceLocation TemplateKWLoc,
            SourceLocation TemplateNameLoc, IdentifierInfo *Name,
            OverloadedOperatorKind OperatorKind,
            ParsedTemplateTy OpaqueTemplateName, TemplateNameKind TemplateKind,
            SourceLocation LAngleLoc, SourceLocation RAngleLoc,
            ArrayRef<ParsedTemplateArgument> TemplateArgs,
            SmallVectorImpl<TemplateIdAnnotation *> &CleanupList) {
-
-      TemplateIdAnnotation *TemplateId = new (std::malloc(
+      TemplateIdAnnotation *TemplateId = new (llvm::safe_malloc(
           totalSizeToAlloc<ParsedTemplateArgument>(TemplateArgs.size())))
           TemplateIdAnnotation(SS, TemplateKWLoc, TemplateNameLoc, Name,
                                OperatorKind, OpaqueTemplateName, TemplateKind,
                                LAngleLoc, RAngleLoc, TemplateArgs);
       CleanupList.push_back(TemplateId);
       return TemplateId;
     }
 

cfe/trunk/lib/AST/NestedNameSpecifier.cpp

static void Append(char *Start, char *End, char *&Buffer, unsigned &BufferSize,
   if (Start == End)
     return;
 
   if (BufferSize + (End - Start) > BufferCapacity) {
     // Reallocate the buffer.
     unsigned NewCapacity = std::max(
         (unsigned)(BufferCapacity ? BufferCapacity * 2 : sizeof(void *) * 2),
         (unsigned)(BufferSize + (End - Start)));
-    char *NewBuffer = static_cast<char *>(malloc(NewCapacity));
+    char *NewBuffer = static_cast<char *>(llvm::safe_malloc(NewCapacity));
     if (BufferCapacity) {
       memcpy(NewBuffer, Buffer, BufferSize);
       free(Buffer);
     }
     Buffer = NewBuffer;
     BufferCapacity = NewCapacity;
   }
 

cfe/trunk/lib/Frontend/CacheTokens.cpp

 ///  keys of the first table).
 ///
 std::pair<Offset,Offset> PTHWriter::EmitIdentifierTable() {
   // Build two maps:
   //  (1) an inverse map from persistent IDs -> (IdentifierInfo*,Offset)
   //  (2) a map from (IdentifierInfo*, Offset)* -> persistent IDs
 
   // Note that we use 'calloc', so all the bytes are 0.
-  PTHIdKey *IIDMap = (PTHIdKey*)calloc(idcount, sizeof(PTHIdKey));
+  PTHIdKey *IIDMap = static_cast<PTHIdKey*>(
+      llvm::safe_calloc(idcount, sizeof(PTHIdKey)));
 
   // Create the hashtable.
   llvm::OnDiskChainedHashTableGenerator<PTHIdentifierTableTrait> IIOffMap;
 
   // Generate mapping from persistent IDs -> IdentifierInfo*.
   for (IDMap::iterator I = IM.begin(), E = IM.end(); I != E; ++I) {
     // Decrement by 1 because we are using a vector for the lookup and
     // 0 is reserved for NULL.

cfe/trunk/lib/Frontend/Rewrite/HTMLPrint.cpp

void HTMLPrinter::HandleTranslationUnit(ASTContext &Ctx) {
   // for example.
 
   if (SyntaxHighlight) html::SyntaxHighlight(R, FID, PP);
   if (HighlightMacros) html::HighlightMacros(R, FID, PP);
   html::EscapeText(R, FID, false, true);
 
   // Emit the HTML.
   const RewriteBuffer &RewriteBuf = R.getEditBuffer(FID);
-  char *Buffer = (char*)malloc(RewriteBuf.size());
-  std::copy(RewriteBuf.begin(), RewriteBuf.end(), Buffer);
-  Out->write(Buffer, RewriteBuf.size());
-  free(Buffer);
+  std::unique_ptr<char[]> Buffer(new char[RewriteBuf.size()]);
+  std::copy(RewriteBuf.begin(), RewriteBuf.end(), Buffer.get());
+  Out->write(Buffer.get(), RewriteBuf.size());
 }

cfe/trunk/lib/Lex/MacroArgs.cpp

if ((*Entry)->NumUnexpArgTokens >= UnexpArgTokens.size() &&
       // Otherwise, use the best fit.
       ClosestMatch = (*Entry)->NumUnexpArgTokens;
     }
   }
   MacroArgs *Result;
   if (!ResultEnt) {
     // Allocate memory for a MacroArgs object with the lexer tokens at the end,
     // and construct the MacroArgs object.
-    Result = new (std::malloc(totalSizeToAlloc<Token>(UnexpArgTokens.size())))
+    Result = new (
+        llvm::safe_malloc(totalSizeToAlloc<Token>(UnexpArgTokens.size())))
         MacroArgs(UnexpArgTokens.size(), VarargsElided, MI->getNumParams());
   } else {
     Result = *ResultEnt;
     // Unlink this node from the preprocessors singly linked list.
     *ResultEnt = Result->ArgCache;
     Result->NumUnexpArgTokens = UnexpArgTokens.size();
     Result->VarargsElided = VarargsElided;
     Result->NumMacroArgs = MI->getNumParams();

cfe/trunk/tools/c-index-test/c-index-test.c

static int parse_remapped_files_with_opt(const char *opt_name,
   }
 
   if (*num_unsaved_files == 0)
     return 0;
 
   *unsaved_files
     = (struct CXUnsavedFile *)malloc(sizeof(struct CXUnsavedFile) *
                                      *num_unsaved_files);
+  assert(*unsaved_files);
   for (i = 0; i != *num_unsaved_files; ++i) {
     struct CXUnsavedFile *unsaved = *unsaved_files + i;
     const char *arg_string = argv[arg_indices[i]] + prefix_len;
     int filename_len;
     char *filename;
     char *contents;
     FILE *to_file;
     const char *sep = strchr(arg_string, ',');
for (i = 0; i != *num_unsaved_files; ++i) {
 
     /* Determine the length of the file we're remapping to. */
     fseek(to_file, 0, SEEK_END);
     unsaved->Length = ftell(to_file);
     fseek(to_file, 0, SEEK_SET);
 
     /* Read the contents of the file we're remapping to. */
     contents = (char *)malloc(unsaved->Length + 1);
+    assert(contents);
     if (fread(contents, 1, unsaved->Length, to_file) != unsaved->Length) {
       fprintf(stderr, "error: unexpected %s reading 'to' file %s\n",
               (feof(to_file) ? "EOF" : "error"), sep + 1);
       fclose(to_file);
       free_remapped_files(*unsaved_files, i);
       free(contents);
       *unsaved_files = 0;
       *num_unsaved_files = 0;
       return -1;
     }
     contents[unsaved->Length] = 0;
     unsaved->Contents = contents;
 
     /* Close the file. */
     fclose(to_file);
 
     /* Copy the file name that we're remapping from. */
     filename_len = sep - arg_string;
     filename = (char *)malloc(filename_len + 1);
+    assert(filename);
     memcpy(filename, arg_string, filename_len);
     filename[filename_len] = 0;
     unsaved->Filename = filename;
   }
 
   return 0;
 }
 
if (num_unsaved_files_try_idx == 0) {
     return 0;
   }
 
   *num_unsaved_files = num_unsaved_files_no_try_idx + num_unsaved_files_try_idx;
   *unsaved_files
     = (struct CXUnsavedFile *)realloc(unsaved_files_no_try_idx,
                                       sizeof(struct CXUnsavedFile) *
                                         *num_unsaved_files);
+  assert(*unsaved_files);
   memcpy(*unsaved_files + num_unsaved_files_no_try_idx,
          unsaved_files_try_idx, sizeof(struct CXUnsavedFile) *
             num_unsaved_files_try_idx);
   free(unsaved_files_try_idx);
   return 0;
 }
 
 static const char *parse_comments_schema(int argc, const char **argv) {
int parse_file_line_column(const char *input, char **filename, unsigned *line,
 
   if (second_line && second_column) {
     *second_line = values[2];
     *second_column = values[3];
   }
 
   /* Copy the file name. */
   *filename = (char*)malloc(last_colon - input + 1);
+  assert(*filename);
   memcpy(*filename, input, last_colon - input);
   (*filename)[last_colon - input] = 0;
   return 0;
 }
 
 const char *
 clang_getCompletionChunkKindSpelling(enum CXCompletionChunkKind Kind) {
   switch (Kind) {
static int inspect_cursor_at(int argc, const char **argv,
   /* Count the number of locations. */
   while (strstr(argv[NumLocations+1], locations_flag) == argv[NumLocations+1])
     ++NumLocations;
 
   /* Parse the locations. */
   assert(NumLocations > 0 && "Unable to count locations?");
   Locations = (CursorSourceLocation *)malloc(
                                   NumLocations * sizeof(CursorSourceLocation));
+  assert(Locations);
   for (Loc = 0; Loc < NumLocations; ++Loc) {
     const char *input = argv[Loc + 1] + strlen(locations_flag);
     if ((errorCode = parse_file_line_column(input, &Locations[Loc].filename,
                                             &Locations[Loc].line,
                                             &Locations[Loc].column, 0, 0)))
       return errorCode;
   }
 
static int find_file_refs_at(int argc, const char **argv) {
   /* Count the number of locations. */
   while (strstr(argv[NumLocations+1], "-file-refs-at=") == argv[NumLocations+1])
     ++NumLocations;
 
   /* Parse the locations. */
   assert(NumLocations > 0 && "Unable to count locations?");
   Locations = (CursorSourceLocation *)malloc(
                                   NumLocations * sizeof(CursorSourceLocation));
+  assert(Locations);
   for (Loc = 0; Loc < NumLocations; ++Loc) {
     const char *input = argv[Loc + 1] + strlen("-file-refs-at=");
     if ((errorCode = parse_file_line_column(input, &Locations[Loc].filename,
                                             &Locations[Loc].line,
                                             &Locations[Loc].column, 0, 0)))
       return errorCode;
   }
 
static int find_file_includes_in(int argc, const char **argv) {
 
   /* Count the number of locations. */
   while (strstr(argv[NumFilenames+1], "-file-includes-in=") == argv[NumFilenames+1])
     ++NumFilenames;
 
   /* Parse the locations. */
   assert(NumFilenames > 0 && "Unable to count filenames?");
   Filenames = (const char **)malloc(NumFilenames * sizeof(const char *));
+  assert(Filenames);
   for (I = 0; I < NumFilenames; ++I) {
     const char *input = argv[I + 1] + strlen("-file-includes-in=");
     /* Copy the file name. */
     Filenames[I] = input;
   }
 
   if (parse_remapped_files(argc, argv, NumFilenames + 1, &unsaved_files,
                            &num_unsaved_files))

 typedef struct {
   char **filenames;
   unsigned num_files;
 } ImportedASTFilesData;
 
 static ImportedASTFilesData *importedASTs_create() {
   ImportedASTFilesData *p;
   p = malloc(sizeof(ImportedASTFilesData));
+  assert(p);
   p->filenames = malloc(MAX_IMPORTED_ASTFILES * sizeof(const char *));
+  assert(p->filenames);
   p->num_files = 0;
   return p;
 }
 
 static void importedASTs_dispose(ImportedASTFilesData *p) {
   unsigned i;
   if (!p)
     return;
static CXIdxClientContainer makeClientContainer(CXClientData *client_data,
   if (!name)
     name = "<anon-tag>";
 
   clang_indexLoc_getFileLocation(loc, &file, 0, &line, &column, 0);
 
   node =
       (IndexDataStringList *)malloc(sizeof(IndexDataStringList) + strlen(name) +
                                     digitCount(line) + digitCount(column) + 2);
+  assert(node);
   newStr = node->data;
   sprintf(newStr, "%s:%d:%d", name, line, column);
 
   /* Remember string so it can be freed later. */
   index_data = (IndexData *)client_data;
   node->next = index_data->strings;
   index_data->strings = node;
 
#define MAX_COMPILE_ARGS 512
     const char *args[MAX_COMPILE_ARGS];
     char *tmp;
     unsigned len;
     char *buildDir;
     int i, a, numCmds, numArgs;
 
     len = strlen(database);
     tmp = (char *) malloc(len+1);
+    assert(tmp);
     memcpy(tmp, database, len+1);
     buildDir = dirname(tmp);
 
     db = clang_CompilationDatabase_fromDirectory(buildDir, &ec);
 
     if (db) {
 
       if (ec!=CXCompilationDatabase_NoError) {
int perform_token_annotation(int argc, const char **argv) {
   clang_tokenize(TU, range, &tokens, &num_tokens);
 
   if (checkForErrors(TU) != 0) {
     errorCode = -1;
     goto teardown;
   }
 
   cursors = (CXCursor *)malloc(num_tokens * sizeof(CXCursor));
+  assert(cursors);
   clang_annotateTokens(TU, tokens, num_tokens, cursors);
 
   if (checkForErrors(TU) != 0) {
     errorCode = -1;
     goto teardown;
   }
 
   skipped_ranges = clang_getSkippedRanges(TU, file);
perform_test_compilation_db(const char *database, int argc, const char **argv) {
   int errorCode = 0;
   char *tmp;
   unsigned len;
   char *buildDir;
   int i, j, a, numCmds, numArgs;
 
   len = strlen(database);
   tmp = (char *) malloc(len+1);
+  assert(tmp);
   memcpy(tmp, database, len+1);
   buildDir = dirname(tmp);
 
   db = clang_CompilationDatabase_fromDirectory(buildDir, &ec);
 
   if (db) {
 
     if (ec!=CXCompilationDatabase_NoError) {

cfe/trunk/tools/libclang/BuildSystem.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang-c/BuildSystem.h"
 #include "CXString.h"
 #include "clang/Basic/VirtualFileSystem.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Chrono.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace llvm::sys;
 
 unsigned long long clang_getBuildSessionTimestamp(void) {
   return llvm::sys::toTimeT(std::chrono::system_clock::now());
clang_VirtualFileOverlay_writeToBuffer(CXVirtualFileOverlay VFO, unsigned,
   if (!VFO || !out_buffer_ptr || !out_buffer_size)
     return CXError_InvalidArguments;
 
   llvm::SmallString<256> Buf;
   llvm::raw_svector_ostream OS(Buf);
   unwrap(VFO)->write(OS);
 
   StringRef Data = OS.str();
-  *out_buffer_ptr = (char*)malloc(Data.size());
+  *out_buffer_ptr = static_cast<char*>(llvm::safe_malloc(Data.size()));
   *out_buffer_size = Data.size();
   memcpy(*out_buffer_ptr, Data.data(), Data.size());
   return CXError_Success;
 }
 
 void clang_free(void *buffer) {
   free(buffer);
 }
clang_ModuleMapDescriptor_writeToBuffer(CXModuleMapDescriptor MMD, unsigned,
   OS << "  umbrella header \"";
   OS.write_escaped(MMD->UmbrellaHeader) << "\"\n";
   OS << '\n';
   OS << "  export *\n";
   OS << "  module * { export * }\n";
   OS << "}\n";
 
   StringRef Data = OS.str();
-  *out_buffer_ptr = (char*)malloc(Data.size());
+  *out_buffer_ptr = static_cast<char*>(llvm::safe_malloc(Data.size()));
   *out_buffer_size = Data.size();
   memcpy(*out_buffer_ptr, Data.data(), Data.size());
   return CXError_Success;
 }
 
 void clang_ModuleMapDescriptor_dispose(CXModuleMapDescriptor MMD) {
   delete MMD;
 }

cfe/trunk/tools/libclang/CIndex.cpp

if (R.isInvalid())
     return;
 
   SmallVector<CXToken, 32> CXTokens;
   getTokens(CXXUnit, R, CXTokens);
 
   if (CXTokens.empty())
     return;
 
-  *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size());
+  *Tokens = static_cast<CXToken *>(
+      llvm::safe_malloc(sizeof(CXToken) * CXTokens.size()));
   memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size());
   *NumTokens = CXTokens.size();
 }
 
 void clang_disposeTokens(CXTranslationUnit TU,
                          CXToken *Tokens, unsigned NumTokens) {
   free(Tokens);
 }

cfe/trunk/tools/libclang/CXString.cpp

CXString createRef(StringRef String) {
   CXString Result;
   Result.data = String.data();
   Result.private_flags = (unsigned) CXS_Unmanaged;
   return Result;
 }
 
 CXString createDup(StringRef String) {
   CXString Result;
-  char *Spelling = static_cast<char *>(malloc(String.size() + 1));
+  char *Spelling = static_cast<char *>(llvm::safe_malloc(String.size() + 1));
   memmove(Spelling, String.data(), String.size());
   Spelling[String.size()] = 0;
   Result.data = Spelling;
   Result.private_flags = (unsigned) CXS_Malloc;
   return Result;
 }
 
 CXString createCXString(CXStringBuf *buf) {