[Fixed Point] [AST] Add an AST serialization code for fixed-point literals.

[ebevhan]

Summary

This patch adds the EXPR_FIXEDPOINT_LITERAL AST
code to serialize FixedPointLiterals. They were previously
being serialized with the code for integer literals, which
doesn't work properly.

[ebevhan]

include/clang/Serialization/ASTBitCodes.h

1637

I'm unsure if this is the right location for a new code. This will bump down all the other codes below this and cause any older file to not be read correctly.

Should the file format version number be bumped up?

[rjmccall]

include/clang/Serialization/ASTBitCodes.h

1637

IIRC the real file format version for this is based on the exact revision of the compiler and there is no pretense of serialized ASTs being sharable between compilers. I don't think we've ever bumped the version number for incompatible changes like this.

[leonardchan]

LGTM. Everything still seems to work on my end after applying this diff.

[vabridgers]

https://reviews.llvm.org/D77721 depends on this serialization change for fixed point literals.

[leonardchan]

In D57226#1969227, @vabridgers wrote:

https://reviews.llvm.org/D77721 depends on this serialization change for fixed point literals.

You could probably take over and land the patch if @ebevhan doesn't respond back soon when you get LGTM for D77721. If you do, just be sure to credit him :)

[rjmccall]

Some minor requests, but otherwise this LGTM.

include/clang/Serialization/ASTBitCodes.h

1637

But really you should add the enumerator to the end of the list.

test/PCH/fixed-point-literal.h

1

Inputs like this generally go into the Inputs directory.

[vabridgers]

Address comments from rjmccall

[rjmccall]

clang/include/clang/Serialization/ASTBitCodes.h

1892 ↗

(On Diff #257183)

Thanks!

I'm sorry to be extremely picky about this, but:

• Please put the comment on the same line and just make it // FixedPointLiteral, like all of the other node-specific comments.
• I think a reformatting of the other comments would be welcome, but if you're going to do it, please do it in a separate commit, and please just indent all of the comments to a consistent column.

[vabridgers]

update based on comments from rjmccall

[vabridgers]

Thank you for the comments. Please do let me know when this patch is ready to land. Best!

[rjmccall]

LGTM, thanks.

include/clang/AST/Expr.h

const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 };
 
 class FixedPointLiteral : public Expr, public APIntStorage {
   SourceLocation Loc;
   unsigned Scale;
 
-  /// \brief Construct an empty integer literal.
+  /// \brief Construct an empty fixed-point literal.
   explicit FixedPointLiteral(EmptyShell Empty)
       : Expr(FixedPointLiteralClass, Empty) {}
 
  public:
   FixedPointLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
                     SourceLocation l, unsigned Scale);
 
   // Store the int as is without any bit shifting.
   static FixedPointLiteral *CreateFromRawInt(const ASTContext &C,
                                              const llvm::APInt &V,
                                              QualType type, SourceLocation l,
                                              unsigned Scale);
 
+  /// Returns an empty fixed-point literal.
+  static FixedPointLiteral *Create(const ASTContext &C, EmptyShell Empty);
+
   SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
   SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
 
   /// \brief Retrieve the location of the literal.
   SourceLocation getLocation() const { return Loc; }
 
   void setLocation(SourceLocation Location) { Loc = Location; }
 
+  unsigned getScale() const { return Scale; }
+  void setScale(unsigned S) { Scale = S; }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == FixedPointLiteralClass;
   }
 
   std::string getValueAsString(unsigned Radix) const;
 
   // Iterators
   child_range children() {

include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
       EXPR_PREDEFINED,
 
       /// A DeclRefExpr record.
       EXPR_DECL_REF,
 
       /// An IntegerLiteral record.
       EXPR_INTEGER_LITERAL,
 
+      /// A FixedPointLiteral record.
+      EXPR_FIXEDPOINT_LITERAL,
+
       /// A FloatingLiteral record.
       EXPR_FLOATING_LITERAL,
 
       /// An ImaginaryLiteral record.
       EXPR_IMAGINARY_LITERAL,
 
       /// A StringLiteral record.
       EXPR_STRING_LITERAL,

lib/AST/Expr.cpp

 FixedPointLiteral *FixedPointLiteral::CreateFromRawInt(const ASTContext &C,
                                                        const llvm::APInt &V,
                                                        QualType type,
                                                        SourceLocation l,
                                                        unsigned Scale) {
   return new (C) FixedPointLiteral(C, V, type, l, Scale);
 }
 
+FixedPointLiteral *FixedPointLiteral::Create(const ASTContext &C,
+                                             EmptyShell Empty) {
+  return new (C) FixedPointLiteral(Empty);
+}
+
 std::string FixedPointLiteral::getValueAsString(unsigned Radix) const {
   // Currently the longest decimal number that can be printed is the max for an
   // unsigned long _Accum: 4294967295.99999999976716935634613037109375
   // which is 43 characters.
   SmallString<64> S;
   FixedPointValueToString(
       S, llvm::APSInt::getUnsigned(getValue().getZExtValue()), Scale);
   return S.str();

lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
   VisitExpr(E);
   E->setLocation(ReadSourceLocation());
   E->setValue(Record.getContext(), Record.readAPInt());
 }
 
 void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) {
   VisitExpr(E);
   E->setLocation(ReadSourceLocation());
+  E->setScale(Record.readInt());
   E->setValue(Record.getContext(), Record.readAPInt());
 }
 
 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
   VisitExpr(E);
   E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record.readInt()));
   E->setExact(Record.readInt());
   E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
case EXPR_DECL_REF:
         /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
           Record[ASTStmtReader::NumExprFields + 5] : 0);
       break;
 
     case EXPR_INTEGER_LITERAL:
       S = IntegerLiteral::Create(Context, Empty);
       break;
 
+    case EXPR_FIXEDPOINT_LITERAL:
+      S = FixedPointLiteral::Create(Context, Empty);
+      break;
+
     case EXPR_FLOATING_LITERAL:
       S = FloatingLiteral::Create(Context, Empty);
       break;
 
     case EXPR_IMAGINARY_LITERAL:
       S = new (Context) ImaginaryLiteral(Empty);
       break;
 

lib/Serialization/ASTWriter.cpp

#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
   RECORD(STMT_BREAK);
   RECORD(STMT_RETURN);
   RECORD(STMT_DECL);
   RECORD(STMT_GCCASM);
   RECORD(STMT_MSASM);
   RECORD(EXPR_PREDEFINED);
   RECORD(EXPR_DECL_REF);
   RECORD(EXPR_INTEGER_LITERAL);
+  RECORD(EXPR_FIXEDPOINT_LITERAL);
   RECORD(EXPR_FLOATING_LITERAL);
   RECORD(EXPR_IMAGINARY_LITERAL);
   RECORD(EXPR_STRING_LITERAL);
   RECORD(EXPR_CHARACTER_LITERAL);
   RECORD(EXPR_PAREN);
   RECORD(EXPR_PAREN_LIST);
   RECORD(EXPR_UNARY_OPERATOR);
   RECORD(EXPR_SIZEOF_ALIGN_OF);

lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
   }
 
   Code = serialization::EXPR_INTEGER_LITERAL;
 }
 
 void ASTStmtWriter::VisitFixedPointLiteral(FixedPointLiteral *E) {
   VisitExpr(E);
   Record.AddSourceLocation(E->getLocation());
+  Record.push_back(E->getScale());
   Record.AddAPInt(E->getValue());
-  Code = serialization::EXPR_INTEGER_LITERAL;
+  Code = serialization::EXPR_FIXEDPOINT_LITERAL;
 }
 
 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
   VisitExpr(E);
   Record.push_back(E->getRawSemantics());
   Record.push_back(E->isExact());
   Record.AddAPFloat(E->getValue());
   Record.AddSourceLocation(E->getLocation());

test/PCH/fixed-point-literal.h

+// Header for PCH test fixed-point-literal.c
+
+const short _Fract sf = -0.25r;
+const _Fract f = 0.75r;
+const long _Accum la = 25.25lk;

test/PCH/fixed-point-literal.c

+// Test this without pch.
+// RUN: %clang_cc1 -ffixed-point -include %S/fixed-point-literal.h -fsyntax-only -ast-print -o - %s | FileCheck %s
+
+// Test with pch.
+// RUN: %clang_cc1 -ffixed-point -emit-pch -o %t %S/fixed-point-literal.h
+// RUN: %clang_cc1 -ffixed-point -include-pch %t -fsyntax-only -ast-print -o - %s | FileCheck %s
+
+// CHECK: const short _Fract sf = -0.25r;
+// CHECK: const _Fract f = 0.75r;
+// CHECK: const long _Accum la = 25.25lk;
+
+short _Fract sf2 = sf;
+_Fract f2 = f;
+long _Accum la2 = la;