]> granicus.if.org Git - clang/commitdiff
Use APFloat for the representation of FP immediates, ask the target
authorChris Lattner <sabre@nondot.org>
Sat, 22 Sep 2007 18:29:59 +0000 (18:29 +0000)
committerChris Lattner <sabre@nondot.org>
Sat, 22 Sep 2007 18:29:59 +0000 (18:29 +0000)
for *which* apfloat to use for a particular type.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@42234 91177308-0d34-0410-b5e6-96231b3b80d8

AST/ASTContext.cpp
Basic/TargetInfo.cpp
Lex/LiteralSupport.cpp
Sema/SemaExpr.cpp
include/clang/AST/Expr.h
include/clang/Basic/TargetInfo.h
include/clang/Lex/LiteralSupport.h

index 6420f0f05112ef70ce9377666b0562db72c81ceb..cb5588b4b73f3758274db829cbdbead31b7f093b 100644 (file)
@@ -190,6 +190,7 @@ ASTContext::getTypeInfo(QualType T, SourceLocation L) {
   case Type::Builtin: {
     // FIXME: need to use TargetInfo to derive the target specific sizes. This
     // implementation will suffice for play with vector support.
+    const llvm::fltSemantics *F;
     switch (cast<BuiltinType>(T)->getKind()) {
     default: assert(0 && "Unknown builtin type!");
     case BuiltinType::Void:
@@ -207,9 +208,9 @@ ASTContext::getTypeInfo(QualType T, SourceLocation L) {
     case BuiltinType::Long:       Target.getLongInfo(Size, Align, L); break;
     case BuiltinType::ULongLong:
     case BuiltinType::LongLong:   Target.getLongLongInfo(Size, Align, L); break;
-    case BuiltinType::Float:      Target.getFloatInfo(Size, Align, L); break;
-    case BuiltinType::Double:     Target.getDoubleInfo(Size, Align, L); break;
-    case BuiltinType::LongDouble: Target.getLongDoubleInfo(Size, Align,L);break;
+    case BuiltinType::Float:      Target.getFloatInfo(Size, Align, F, L); break;
+    case BuiltinType::Double:     Target.getDoubleInfo(Size, Align, F, L);break;
+    case BuiltinType::LongDouble:Target.getLongDoubleInfo(Size,Align,F,L);break;
     }
     break;
   }
index 1b780108e5e924493e2164efdf153f67c0076b07..2b0af7ed24c96cfa1f01f9196ddf269df02e854c 100644 (file)
 #include "clang/Basic/Diagnostic.h"
 #include "clang/AST/Builtins.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/APFloat.h"
 #include <set>
 using namespace clang;
 
 void TargetInfoImpl::ANCHOR() {} // out-of-line virtual method for class.
 
 
+//===----------------------------------------------------------------------===//
+// FIXME: These are temporary hacks, they should revector into the
+// TargetInfoImpl.
+
+void TargetInfo::getFloatInfo(uint64_t &Size, unsigned &Align,
+                              const llvm::fltSemantics *&Format,
+                              SourceLocation Loc) {
+  Align = 32;  // FIXME: implement correctly.
+  Size = 32;
+  Format = &llvm::APFloat::IEEEsingle;
+}
+void TargetInfo::getDoubleInfo(uint64_t &Size, unsigned &Align,
+                               const llvm::fltSemantics *&Format,
+                               SourceLocation Loc) {
+  Size = Align = 64;  // FIXME: implement correctly.
+  Format = &llvm::APFloat::IEEEdouble;
+}
+void TargetInfo::getLongDoubleInfo(uint64_t &Size, unsigned &Align,
+                                   const llvm::fltSemantics *&Format,
+                                   SourceLocation Loc) {
+  Size = 80; Align = 32;  // FIXME: implement correctly.
+  Format = &llvm::APFloat::x87DoubleExtended;
+}
+
+
+//===----------------------------------------------------------------------===//
+
 /// DiagnoseNonPortability - When a use of a non-portable target feature is
 /// used, this method emits the diagnostic and marks the translation unit as
 /// non-portable.
index c2bdd8e5f5b7c8ce2d4253e652df9174f62b6623..3449c2769af4cf5165b5f66c1b435960cd189a04 100644 (file)
@@ -17,7 +17,6 @@
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
-#include "llvm/ADT/APInt.h"
 #include "llvm/ADT/StringExtras.h"
 using namespace clang;
 
@@ -411,11 +410,12 @@ bool NumericLiteralParser::GetIntegerValue(llvm::APInt &Val) {
 }
 
 // GetFloatValue - Poor man's floatvalue (FIXME).
-float NumericLiteralParser::GetFloatValue() {
+llvm::APFloat NumericLiteralParser::
+GetFloatValue(const llvm::fltSemantics &Format) {
   char floatChars[256];
   strncpy(floatChars, ThisTokBegin, ThisTokEnd-ThisTokBegin);
   floatChars[ThisTokEnd-ThisTokBegin] = '\0';
-  return (float)strtod(floatChars, 0);
+  return llvm::APFloat(Format, floatChars);
 }
 
 void NumericLiteralParser::Diag(SourceLocation Loc, unsigned DiagID, 
index 11c3eccb36a7b3662db3d64cc47d3b1e0fafeaee..15bf4fd0cb630e67e6e0659069b426dac7edb52d 100644 (file)
@@ -150,9 +150,23 @@ Action::ExprResult Sema::ActOnNumericConstant(const Token &Tok) {
   Expr *Res;
   
   if (Literal.isFloatingLiteral()) {
-    // FIXME: handle float values > 32 (including compute the real type...).
-    QualType Ty = Literal.isFloat ? Context.FloatTy : Context.DoubleTy;
-    Res = new FloatingLiteral(Literal.GetFloatValue(), Ty, Tok.getLocation());
+    QualType Ty;
+    const llvm::fltSemantics *Format;
+    uint64_t Size; unsigned Align;
+
+    if (Literal.isFloat) {
+      Ty = Context.FloatTy;
+      Context.Target.getFloatInfo(Size, Align, Format, Tok.getLocation());
+    } else if (Literal.isLong) {
+      Ty = Context.LongDoubleTy;
+      Context.Target.getLongDoubleInfo(Size, Align, Format, Tok.getLocation());
+    } else {
+      Ty = Context.DoubleTy;
+      Context.Target.getDoubleInfo(Size, Align, Format, Tok.getLocation());
+    }
+    
+    Res = new FloatingLiteral(Literal.GetFloatValue(*Format), Ty,
+                              Tok.getLocation());
   } else if (!Literal.isIntegerLiteral()) {
     return ExprResult(true);
   } else {
index 24eecf597c1a2348c51c4c9e5c11d3709db1a5e1..08b2b6c03674305d1ae5f7b4ed5fd38c636e38bd 100644 (file)
@@ -18,6 +18,7 @@
 #include "clang/AST/Type.h"
 #include "clang/AST/Decl.h"
 #include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/APFloat.h"
 
 namespace clang {
   class IdentifierInfo;
@@ -216,13 +217,13 @@ public:
 };
 
 class FloatingLiteral : public Expr {
-  float Value; // FIXME: Change to APFloat
+  llvm::APFloat Value;
   SourceLocation Loc;
 public:
-  FloatingLiteral(float value, QualType type, SourceLocation l)
-    : Expr(FloatingLiteralClass, type), Value(value), Loc(l) {} 
+  FloatingLiteral(const llvm::APFloat &V, QualType Type, SourceLocation L)
+    : Expr(FloatingLiteralClass, Type), Value(V), Loc(L) {} 
 
-  float getValue() const { return Value; }
+  float getValue() const { return Value.convertToDouble(); }
   
   virtual SourceRange getSourceRange() const { return SourceRange(Loc); }
 
index 72cde09c38d0b06c9a36f663d51316742365fb04..f437e4b712bff9d331ed160531c86cc1cc8a23dd 100644 (file)
@@ -19,6 +19,8 @@
 #include <vector>
 #include <string>
 
+namespace llvm { struct fltSemantics; }
+
 namespace clang {
 
 class TargetInfoImpl;
@@ -148,23 +150,17 @@ public:
     Size = Align = 64; // FIXME: implement correctly.
   }
   
-  /// getFloatInfo - Return the size of 'float' for this target, in bits.  
-  void getFloatInfo(uint64_t &Size, unsigned &Align, SourceLocation Loc) {
-    Align = 32;  // FIXME: implement correctly.
-    Size = 32;
-  }
+  /// getFloatInfo - Characterize 'float' for this target.  
+  void getFloatInfo(uint64_t &Size, unsigned &Align,
+                    const llvm::fltSemantics *&Format, SourceLocation Loc);
 
-  /// getDoubleInfo - Return the size of 'double' for this target, in bits.  
-  void getDoubleInfo(uint64_t &Size, unsigned &Align, SourceLocation Loc) {
-    Size = Align = 64;  // FIXME: implement correctly.
-  }
+  /// getDoubleInfo - Characterize 'double' for this target.
+  void getDoubleInfo(uint64_t &Size, unsigned &Align,
+                     const llvm::fltSemantics *&Format,  SourceLocation Loc);
 
-  /// getLongDoubleInfo - Return the size of 'long double' for this target, in
-  /// bits.  
+  /// getLongDoubleInfo - Characterize 'long double' for this target.
   void getLongDoubleInfo(uint64_t &Size, unsigned &Align,
-                             SourceLocation Loc) {
-    Size = Align = 64;  // FIXME: implement correctly.
-  }
+                         const llvm::fltSemantics *&Format, SourceLocation Loc);
   
   /// getWCharInfo - Return the size of wchar_t in bits.
   ///
index 9c4c4cd924760c428bef92880fcb206986bda6ef..dde2d9197630d44c552a4711a2924396cda644df 100644 (file)
@@ -20,6 +20,8 @@
 
 namespace llvm {
   class APInt;
+  class APFloat;
+  struct fltSemantics;
 }
 
 namespace clang {
@@ -73,9 +75,10 @@ public:
   /// bits of the result and return true.  Otherwise, return false.
   bool GetIntegerValue(llvm::APInt &Val);
   
-  /// GetFloatValue - Convert this numeric literal to a float.
-  /// FIXME: the return value is fixed size - make more general.
-  float GetFloatValue();
+  /// GetFloatValue - Convert this numeric literal to a floating value, using
+  /// the specified APFloat fltSemantics (specifying float, double, etc).
+  ///
+  llvm::APFloat GetFloatValue(const llvm::fltSemantics &Format);
 
 private:  
   void Diag(SourceLocation Loc, unsigned DiagID,