4 files changed, 256 insertions, 166 deletions

diff --git a/lib/Basic/Diagnostic.cpp b/lib/Basic/Diagnostic.cpp
index 094f7760a8ec..f7ec873e4c15 100644
--- a/lib/Basic/Diagnostic.cpp
+++ b/lib/Basic/Diagnostic.cpp
@@ -387,123 +387,6 @@ Diagnostic::getDiagnosticLevel(unsigned DiagID, unsigned DiagClass) const {
   return Result;
 }
 
-static bool ReadUnsigned(const char *&Memory, const char *MemoryEnd,
-                         unsigned &Value) {
-  if (Memory + sizeof(unsigned) > MemoryEnd)
-    return true;
-
-  memmove(&Value, Memory, sizeof(unsigned));
-  Memory += sizeof(unsigned);
-  return false;
-}
-
-static bool ReadSourceLocation(FileManager &FM, SourceManager &SM,
-                               const char *&Memory, const char *MemoryEnd,
-                               SourceLocation &Location) {
-  // Read the filename.
-  unsigned FileNameLen = 0;
-  if (ReadUnsigned(Memory, MemoryEnd, FileNameLen) || 
-      Memory + FileNameLen > MemoryEnd)
-    return true;
-
-  llvm::StringRef FileName(Memory, FileNameLen);
-  Memory += FileNameLen;
-
-  // Read the line, column.
-  unsigned Line = 0, Column = 0;
-  if (ReadUnsigned(Memory, MemoryEnd, Line) ||
-      ReadUnsigned(Memory, MemoryEnd, Column))
-    return true;
-
-  if (FileName.empty()) {
-    Location = SourceLocation();
-    return false;
-  }
-
-  const FileEntry *File = FM.getFile(FileName);
-  if (!File)
-    return true;
-
-  // Make sure that this file has an entry in the source manager.
-  if (!SM.hasFileInfo(File))
-    SM.createFileID(File, SourceLocation(), SrcMgr::C_User);
-
-  Location = SM.getLocation(File, Line, Column);
-  return false;
-}
-
-DiagnosticBuilder Diagnostic::Deserialize(FileManager &FM, SourceManager &SM, 
-                                          const char *&Memory, 
-                                          const char *MemoryEnd) {
-  if (Memory == MemoryEnd)
-    return DiagnosticBuilder(0);
-
-  // Read the severity level.
-  unsigned Level = 0;
-  if (ReadUnsigned(Memory, MemoryEnd, Level) || Level > Fatal)
-    return DiagnosticBuilder(0);
-
-  // Read the source location.
-  SourceLocation Location;
-  if (ReadSourceLocation(FM, SM, Memory, MemoryEnd, Location))
-    return DiagnosticBuilder(0);
-
-  // Read the diagnostic text.
-  if (Memory == MemoryEnd)
-    return DiagnosticBuilder(0);
-
-  unsigned MessageLen = 0;
-  if (ReadUnsigned(Memory, MemoryEnd, MessageLen) ||
-      Memory + MessageLen > MemoryEnd)
-    return DiagnosticBuilder(0);
-  
-  llvm::StringRef Message(Memory, MessageLen);
-  Memory += MessageLen;
-
-  // At this point, we have enough information to form a diagnostic. Do so.
-  unsigned DiagID = getCustomDiagID((enum Level)Level, Message);
-  DiagnosticBuilder DB = Report(FullSourceLoc(Location, SM), DiagID);
-  if (Memory == MemoryEnd)
-    return DB;
-
-  // Read the source ranges.
-  unsigned NumSourceRanges = 0;
-  if (ReadUnsigned(Memory, MemoryEnd, NumSourceRanges))
-    return DB;
-  for (unsigned I = 0; I != NumSourceRanges; ++I) {
-    SourceLocation Begin, End;
-    if (ReadSourceLocation(FM, SM, Memory, MemoryEnd, Begin) ||
-        ReadSourceLocation(FM, SM, Memory, MemoryEnd, End))
-      return DB;
-
-    DB << SourceRange(Begin, End);
-  }
-
-  // Read the fix-it hints.
-  unsigned NumFixIts = 0;
-  if (ReadUnsigned(Memory, MemoryEnd, NumFixIts))
-    return DB;
-  for (unsigned I = 0; I != NumFixIts; ++I) {
-    SourceLocation RemoveBegin, RemoveEnd, InsertionLoc;
-    unsigned InsertLen = 0;
-    if (ReadSourceLocation(FM, SM, Memory, MemoryEnd, RemoveBegin) ||
-        ReadSourceLocation(FM, SM, Memory, MemoryEnd, RemoveEnd) ||
-        ReadSourceLocation(FM, SM, Memory, MemoryEnd, InsertionLoc) ||
-        ReadUnsigned(Memory, MemoryEnd, InsertLen) ||
-        Memory + InsertLen > MemoryEnd)
-      return DB;
-
-    CodeModificationHint Hint;
-    Hint.RemoveRange = SourceRange(RemoveBegin, RemoveEnd);
-    Hint.InsertionLoc = InsertionLoc;
-    Hint.CodeToInsert.assign(Memory, Memory + InsertLen);
-    Memory += InsertLen;
-    DB << Hint;
-  }
-
-  return DB;
-}
-
 struct WarningOption {
   const char  *Name;
   const short *Members;
@@ -1036,6 +919,31 @@ FormatDiagnostic(const char *DiagStr, const char *DiagEnd,
   }
 }
 
+StoredDiagnostic::StoredDiagnostic() { }
+
+StoredDiagnostic::StoredDiagnostic(Diagnostic::Level Level, 
+                                   llvm::StringRef Message)
+  : Level(Level), Loc(), Message(Message) { }
+
+StoredDiagnostic::StoredDiagnostic(Diagnostic::Level Level, 
+                                   const DiagnosticInfo &Info)
+  : Level(Level), Loc(Info.getLocation()) 
+{
+  llvm::SmallString<64> Message;
+  Info.FormatDiagnostic(Message);
+  this->Message.assign(Message.begin(), Message.end());
+
+  Ranges.reserve(Info.getNumRanges());
+  for (unsigned I = 0, N = Info.getNumRanges(); I != N; ++I)
+    Ranges.push_back(Info.getRange(I));
+
+  FixIts.reserve(Info.getNumCodeModificationHints());
+  for (unsigned I = 0, N = Info.getNumCodeModificationHints(); I != N; ++I)
+    FixIts.push_back(Info.getCodeModificationHint(I));
+}
+
+StoredDiagnostic::~StoredDiagnostic() { }
+
 static void WriteUnsigned(llvm::raw_ostream &OS, unsigned Value) {
   OS.write((const char *)&Value, sizeof(unsigned));
 }
@@ -1065,27 +973,27 @@ static void WriteSourceLocation(llvm::raw_ostream &OS,
   WriteUnsigned(OS, SM->getColumnNumber(Decomposed.first, Decomposed.second));
 }
 
-void DiagnosticInfo::Serialize(Diagnostic::Level DiagLevel, 
-                               llvm::raw_ostream &OS) const {
+void StoredDiagnostic::Serialize(llvm::raw_ostream &OS) const {
   SourceManager *SM = 0;
   if (getLocation().isValid())
     SM = &const_cast<SourceManager &>(getLocation().getManager());
 
+  // Write a short header to help identify diagnostics.
+  OS << (char)0x06 << (char)0x07;
+  
   // Write the diagnostic level and location.
-  WriteUnsigned(OS, (unsigned)DiagLevel);
+  WriteUnsigned(OS, (unsigned)Level);
   WriteSourceLocation(OS, SM, getLocation());
 
   // Write the diagnostic message.
   llvm::SmallString<64> Message;
-  FormatDiagnostic(Message);
-  WriteString(OS, Message);
+  WriteString(OS, getMessage());
   
   // Count the number of ranges that don't point into macros, since
   // only simple file ranges serialize well.
   unsigned NumNonMacroRanges = 0;
-  for (unsigned I = 0, N = getNumRanges(); I != N; ++I) {
-    SourceRange R = getRange(I);
-    if (R.getBegin().isMacroID() || R.getEnd().isMacroID())
+  for (range_iterator R = range_begin(), REnd = range_end(); R != REnd; ++R) {
+    if (R->getBegin().isMacroID() || R->getEnd().isMacroID())
       continue;
 
     ++NumNonMacroRanges;
@@ -1094,44 +1002,185 @@ void DiagnosticInfo::Serialize(Diagnostic::Level DiagLevel,
   // Write the ranges.
   WriteUnsigned(OS, NumNonMacroRanges);
   if (NumNonMacroRanges) {
-    for (unsigned I = 0, N = getNumRanges(); I != N; ++I) {
-      SourceRange R = getRange(I);
-      if (R.getBegin().isMacroID() || R.getEnd().isMacroID())
+    for (range_iterator R = range_begin(), REnd = range_end(); R != REnd; ++R) {
+      if (R->getBegin().isMacroID() || R->getEnd().isMacroID())
         continue;
       
-      WriteSourceLocation(OS, SM, R.getBegin());
-      WriteSourceLocation(OS, SM, R.getEnd());
+      WriteSourceLocation(OS, SM, R->getBegin());
+      WriteSourceLocation(OS, SM, R->getEnd());
     }
   }
 
   // Determine if all of the fix-its involve rewrites with simple file
   // locations (not in macro instantiations). If so, we can write
   // fix-it information.
-  unsigned NumFixIts = getNumCodeModificationHints();
-  for (unsigned I = 0; I != NumFixIts; ++I) {
-    const CodeModificationHint &Hint = getCodeModificationHint(I);
-    if (Hint.RemoveRange.isValid() &&
-        (Hint.RemoveRange.getBegin().isMacroID() ||
-         Hint.RemoveRange.getEnd().isMacroID())) {
+  unsigned NumFixIts = 0;
+  for (fixit_iterator F = fixit_begin(), FEnd = fixit_end(); F != FEnd; ++F) {
+    if (F->RemoveRange.isValid() &&
+        (F->RemoveRange.getBegin().isMacroID() ||
+         F->RemoveRange.getEnd().isMacroID())) {
       NumFixIts = 0;
       break;
     }
 
-    if (Hint.InsertionLoc.isValid() && Hint.InsertionLoc.isMacroID()) {
+    if (F->InsertionLoc.isValid() && F->InsertionLoc.isMacroID()) {
       NumFixIts = 0;
       break;
     }
+
+    ++NumFixIts;
   }
 
   // Write the fix-its.
   WriteUnsigned(OS, NumFixIts);
+  for (fixit_iterator F = fixit_begin(), FEnd = fixit_end(); F != FEnd; ++F) {
+    WriteSourceLocation(OS, SM, F->RemoveRange.getBegin());
+    WriteSourceLocation(OS, SM, F->RemoveRange.getEnd());
+    WriteSourceLocation(OS, SM, F->InsertionLoc);
+    WriteString(OS, F->CodeToInsert);
+  }
+}
+
+static bool ReadUnsigned(const char *&Memory, const char *MemoryEnd,
+                         unsigned &Value) {
+  if (Memory + sizeof(unsigned) > MemoryEnd)
+    return true;
+
+  memmove(&Value, Memory, sizeof(unsigned));
+  Memory += sizeof(unsigned);
+  return false;
+}
+
+static bool ReadSourceLocation(FileManager &FM, SourceManager &SM,
+                               const char *&Memory, const char *MemoryEnd,
+                               SourceLocation &Location) {
+  // Read the filename.
+  unsigned FileNameLen = 0;
+  if (ReadUnsigned(Memory, MemoryEnd, FileNameLen) || 
+      Memory + FileNameLen > MemoryEnd)
+    return true;
+
+  llvm::StringRef FileName(Memory, FileNameLen);
+  Memory += FileNameLen;
+
+  // Read the line, column.
+  unsigned Line = 0, Column = 0;
+  if (ReadUnsigned(Memory, MemoryEnd, Line) ||
+      ReadUnsigned(Memory, MemoryEnd, Column))
+    return true;
+
+  if (FileName.empty()) {
+    Location = SourceLocation();
+    return false;
+  }
+
+  const FileEntry *File = FM.getFile(FileName);
+  if (!File)
+    return true;
+
+  // Make sure that this file has an entry in the source manager.
+  if (!SM.hasFileInfo(File))
+    SM.createFileID(File, SourceLocation(), SrcMgr::C_User);
+
+  Location = SM.getLocation(File, Line, Column);
+  return false;
+}
+
+StoredDiagnostic 
+StoredDiagnostic::Deserialize(FileManager &FM, SourceManager &SM, 
+                              const char *&Memory, const char *MemoryEnd) {
+  while (true) {
+    if (Memory == MemoryEnd)
+      return StoredDiagnostic();
+    
+    if (*Memory != 0x06) {
+      ++Memory;
+      continue;
+    }
+    
+    ++Memory;
+    if (Memory == MemoryEnd)
+      return StoredDiagnostic();
+  
+    if (*Memory != 0x07) {
+      ++Memory;
+      continue;
+    }
+    
+    // We found the header. We're done.
+    ++Memory;
+    break;
+  }
+  
+  // Read the severity level.
+  unsigned Level = 0;
+  if (ReadUnsigned(Memory, MemoryEnd, Level) || Level > Diagnostic::Fatal)
+    return StoredDiagnostic();
+
+  // Read the source location.
+  SourceLocation Location;
+  if (ReadSourceLocation(FM, SM, Memory, MemoryEnd, Location))
+    return StoredDiagnostic();
+
+  // Read the diagnostic text.
+  if (Memory == MemoryEnd)
+    return StoredDiagnostic();
+
+  unsigned MessageLen = 0;
+  if (ReadUnsigned(Memory, MemoryEnd, MessageLen) ||
+      Memory + MessageLen > MemoryEnd)
+    return StoredDiagnostic();
+  
+  llvm::StringRef Message(Memory, MessageLen);
+  Memory += MessageLen;
+
+
+  // At this point, we have enough information to form a diagnostic. Do so.
+  StoredDiagnostic Diag;
+  Diag.Level = (Diagnostic::Level)Level;
+  Diag.Loc = FullSourceLoc(Location, SM);
+  Diag.Message = Message;
+  if (Memory == MemoryEnd)
+    return Diag;
+
+  // Read the source ranges.
+  unsigned NumSourceRanges = 0;
+  if (ReadUnsigned(Memory, MemoryEnd, NumSourceRanges))
+    return Diag;
+  for (unsigned I = 0; I != NumSourceRanges; ++I) {
+    SourceLocation Begin, End;
+    if (ReadSourceLocation(FM, SM, Memory, MemoryEnd, Begin) ||
+        ReadSourceLocation(FM, SM, Memory, MemoryEnd, End))
+      return Diag;
+
+    Diag.Ranges.push_back(SourceRange(Begin, End));
+  }
+
+  // Read the fix-it hints.
+  unsigned NumFixIts = 0;
+  if (ReadUnsigned(Memory, MemoryEnd, NumFixIts))
+    return Diag;
   for (unsigned I = 0; I != NumFixIts; ++I) {
-    const CodeModificationHint &Hint = getCodeModificationHint(I);
-    WriteSourceLocation(OS, SM, Hint.RemoveRange.getBegin());
-    WriteSourceLocation(OS, SM, Hint.RemoveRange.getEnd());
-    WriteSourceLocation(OS, SM, Hint.InsertionLoc);
-    WriteString(OS, Hint.CodeToInsert);
+    SourceLocation RemoveBegin, RemoveEnd, InsertionLoc;
+    unsigned InsertLen = 0;
+    if (ReadSourceLocation(FM, SM, Memory, MemoryEnd, RemoveBegin) ||
+        ReadSourceLocation(FM, SM, Memory, MemoryEnd, RemoveEnd) ||
+        ReadSourceLocation(FM, SM, Memory, MemoryEnd, InsertionLoc) ||
+        ReadUnsigned(Memory, MemoryEnd, InsertLen) ||
+        Memory + InsertLen > MemoryEnd) {
+      Diag.FixIts.clear();
+      return Diag;
+    }
+
+    CodeModificationHint Hint;
+    Hint.RemoveRange = SourceRange(RemoveBegin, RemoveEnd);
+    Hint.InsertionLoc = InsertionLoc;
+    Hint.CodeToInsert.assign(Memory, Memory + InsertLen);
+    Memory += InsertLen;
+    Diag.FixIts.push_back(Hint);
   }
+
+  return Diag;
 }
 
 /// IncludeInDiagnosticCounts - This method (whose default implementation
diff --git a/lib/Basic/SourceManager.cpp b/lib/Basic/SourceManager.cpp
index b91671ad17b1..0c22de7bddb1 100644
--- a/lib/Basic/SourceManager.cpp
+++ b/lib/Basic/SourceManager.cpp
@@ -980,20 +980,6 @@ SourceLocation SourceManager::getLocation(const FileEntry *SourceFile,
   if (Content->SourceLineCache == 0)
     ComputeLineNumbers(Content, ContentCacheAlloc);
 
-  if (Line > Content->NumLines)
-    return SourceLocation();
-
-  unsigned FilePos = Content->SourceLineCache[Line - 1];
-  const char *Buf = Content->getBuffer()->getBufferStart() + FilePos;
-  unsigned BufLength = Content->getBuffer()->getBufferEnd() - Buf;
-  unsigned i = 0;
-
-  // Check that the given column is valid.
-  while (i < BufLength-1 && i < Col-1 && Buf[i] != '\n' && Buf[i] != '\r')
-    ++i;
-  if (i < Col-1)
-    return SourceLocation();
-
   // Find the first file ID that corresponds to the given file.
   FileID FirstFID;
 
@@ -1020,6 +1006,24 @@ SourceLocation SourceManager::getLocation(const FileEntry *SourceFile,
   if (FirstFID.isInvalid())
     return SourceLocation();
 
+  if (Line > Content->NumLines) {
+    unsigned Size = Content->getBuffer()->getBufferSize();
+    if (Size > 0)
+      --Size;
+    return getLocForStartOfFile(FirstFID).getFileLocWithOffset(Size);
+  }
+
+  unsigned FilePos = Content->SourceLineCache[Line - 1];
+  const char *Buf = Content->getBuffer()->getBufferStart() + FilePos;
+  unsigned BufLength = Content->getBuffer()->getBufferEnd() - Buf;
+  unsigned i = 0;
+
+  // Check that the given column is valid.
+  while (i < BufLength-1 && i < Col-1 && Buf[i] != '\n' && Buf[i] != '\r')
+    ++i;
+  if (i < Col-1)
+    return getLocForStartOfFile(FirstFID).getFileLocWithOffset(FilePos + i);
+
   return getLocForStartOfFile(FirstFID).getFileLocWithOffset(FilePos + Col - 1);
 }
 
diff --git a/lib/Basic/Targets.cpp b/lib/Basic/Targets.cpp
index c1cd96e361ed..b8fe53599b52 100644
--- a/lib/Basic/Targets.cpp
+++ b/lib/Basic/Targets.cpp
@@ -436,11 +436,13 @@ void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
   // Target identification.
   Builder.defineMacro("__ppc__");
   Builder.defineMacro("_ARCH_PPC");
+  Builder.defineMacro("__powerpc__");
   Builder.defineMacro("__POWERPC__");
   if (PointerWidth == 64) {
     Builder.defineMacro("_ARCH_PPC64");
     Builder.defineMacro("_LP64");
     Builder.defineMacro("__LP64__");
+    Builder.defineMacro("__powerpc64__");
     Builder.defineMacro("__ppc64__");
   } else {
     Builder.defineMacro("__ppc__");
@@ -571,9 +573,12 @@ void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
 namespace {
 class PPC32TargetInfo : public PPCTargetInfo {
 public:
-  PPC32TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
+  PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
     DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
                         "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
+
+    if (getTriple().getOS() == llvm::Triple::FreeBSD)
+        this->SizeType = TargetInfo::UnsignedInt;
   }
 };
 } // end anonymous namespace.
@@ -1919,13 +1924,39 @@ namespace {
 
 namespace {
 class MipsTargetInfo : public TargetInfo {
+  std::string ABI, CPU;
   static const TargetInfo::GCCRegAlias GCCRegAliases[];
   static const char * const GCCRegNames[];
 public:
-  MipsTargetInfo(const std::string& triple) : TargetInfo(triple) {
+  MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
     DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
                         "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
   }
+  virtual const char *getABI() const { return ABI.c_str(); }
+  virtual bool setABI(const std::string &Name) {
+
+    if ((Name == "o32") || (Name == "eabi")) {
+      ABI = Name;
+      return true;
+    } else
+      return false;
+  }
+  virtual bool setCPU(const std::string &Name) {
+    CPU = Name;
+    return true;
+  }
+  void getDefaultFeatures(const std::string &CPU,
+                          llvm::StringMap<bool> &Features) const {
+    Features[ABI] = true;
+    Features[CPU] = true;
+  }
+  virtual void getArchDefines(const LangOptions &Opts,
+                                MacroBuilder &Builder) const {
+    if (ABI == "o32")
+      Builder.defineMacro("__mips_o32");
+    else if (ABI == "eabi")
+      Builder.defineMacro("__mips_eabi");
+  }
   virtual void getTargetDefines(const LangOptions &Opts,
                                 MacroBuilder &Builder) const {
     DefineStd(Builder, "mips", Opts);
@@ -1933,6 +1964,7 @@ public:
     DefineStd(Builder, "MIPSEB", Opts);
     Builder.defineMacro("_MIPSEB");
     Builder.defineMacro("__REGISTER_PREFIX__", "");
+    getArchDefines(Opts, Builder);
   }
   virtual void getTargetBuiltins(const Builtin::Info *&Records,
                                  unsigned &NumRecords) const {
@@ -2044,6 +2076,7 @@ void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
   DefineStd(Builder, "MIPSEL", Opts);
   Builder.defineMacro("_MIPSEL");
   Builder.defineMacro("__REGISTER_PREFIX__", "");
+  getArchDefines(Opts, Builder);
 }
 } // end anonymous namespace.
 
@@ -2096,6 +2129,8 @@ static TargetInfo *AllocateTarget(const std::string &T) {
   case llvm::Triple::ppc:
     if (os == llvm::Triple::Darwin)
       return new DarwinTargetInfo<PPCTargetInfo>(T);
+    else if (os == llvm::Triple::FreeBSD)
+      return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
     return new PPC32TargetInfo(T);
 
   case llvm::Triple::ppc64:
@@ -2103,6 +2138,8 @@ static TargetInfo *AllocateTarget(const std::string &T) {
       return new DarwinTargetInfo<PPC64TargetInfo>(T);
     else if (os == llvm::Triple::Lv2)
       return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
+    else if (os == llvm::Triple::FreeBSD)
+      return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
     return new PPC64TargetInfo(T);
 
   case llvm::Triple::sparc:
diff --git a/lib/Basic/Version.cpp b/lib/Basic/Version.cpp
index 98cf42b8c3d9..4d903055b5b9 100644
--- a/lib/Basic/Version.cpp
+++ b/lib/Basic/Version.cpp
@@ -40,15 +40,15 @@ llvm::StringRef getClangRepositoryPath() {
 }
 
 std::string getClangRevision() {
-#ifndef SVN_REVISION
-  // Subversion was not available at build time?
-  return "";
-#else
-  std::string revision;
-  llvm::raw_string_ostream OS(revision);
-  OS << strtol(SVN_REVISION, 0, 10);
-  return revision;
+#ifdef SVN_REVISION
+  if (SVN_REVISION[0] != '\0') {
+    std::string revision;
+    llvm::raw_string_ostream OS(revision);
+    OS << strtol(SVN_REVISION, 0, 10);
+    return revision;
+  }
 #endif
+  return "";
 }
 
 std::string getClangFullRepositoryVersion() {