Auto merge of #233 - fitzgen:float128, r=emilio

Add rudimentary support for `__float128`

This adds `__float128` as a builtin type, and generates an opaque array
of 16 `u8`s to represent it in the generated bindings since Rust doesn't
have an `f128` type.

Context and motivation: Somehow `__float128` is getting pulled into
SpiderMonkey headers from somewhere, and the lack of `__float128`
support was causing bindgen to hard fail in bindings generation.

r? @emilio

4 files changed, 23 insertions, 21 deletions

diff --git a/src/clangll.rs b/src/clangll.rs
index b89c0756..b9743117 100644
--- a/src/clangll.rs
+++ b/src/clangll.rs
@@ -392,6 +392,7 @@ pub const CXType_Dependent: c_uint = 26;
 pub const CXType_ObjCId: c_uint = 27;
 pub const CXType_ObjCClass: c_uint = 28;
 pub const CXType_ObjCSel: c_uint = 29;
+pub const CXType_Float128: c_uint = 30;
 pub const CXType_FirstBuiltin: c_uint = 2;
 pub const CXType_LastBuiltin: c_uint = 29;
 pub const CXType_Complex: c_uint = 100;
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 5e68da14..3bee69b6 100755
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -1609,27 +1609,22 @@ impl ToRustTy for Type {
                 }
             }
             TypeKind::Float(fk) => {
+                // TODO: we probably should just take the type layout into
+                // account?
+                //
+                // Also, maybe this one shouldn't be the default?
+                //
+                // FIXME: `c_longdouble` doesn't seem to be defined in some
+                // systems, so we use `c_double` directly.
                 use ir::ty::FloatKind;
-                if ctx.options().convert_floats {
-                    // TODO: we probably should just take the type layout into
-                    // account?
-                    //
-                    // Also, maybe this one shouldn't be the default?
-                    match fk {
-                        FloatKind::Float => aster::ty::TyBuilder::new().f32(),
-                        FloatKind::Double | FloatKind::LongDouble => {
-                            aster::ty::TyBuilder::new().f64()
-                        }
-                    }
-                } else {
-                    // FIXME: `c_longdouble` doesn't seem to be defined in some
-                    // systems, so we use `c_double` directly.
-                    match fk {
-                        FloatKind::Float => raw!(c_float),
-                        FloatKind::Double | FloatKind::LongDouble => {
-                            raw!(c_double)
-                        }
-                    }
+                match (fk, ctx.options().convert_floats) {
+                    (FloatKind::Float, true) => aster::ty::TyBuilder::new().f32(),
+                    (FloatKind::Double, true) |
+                    (FloatKind::LongDouble, true) => aster::ty::TyBuilder::new().f64(),
+                    (FloatKind::Float, false) => raw!(c_float),
+                    (FloatKind::Double, false) |
+                    (FloatKind::LongDouble, false) => raw!(c_double),
+                    (FloatKind::Float128, _) => aster::ty::TyBuilder::new().array(16).u8(),
                 }
             }
             TypeKind::Function(ref fs) => {
diff --git a/src/ir/context.rs b/src/ir/context.rs
index 00ece529..92c6fb49 100644
--- a/src/ir/context.rs
+++ b/src/ir/context.rs
@@ -697,6 +697,7 @@ impl<'ctx> BindgenContext<'ctx> {
             CXType_Float => TypeKind::Float(FloatKind::Float),
             CXType_Double => TypeKind::Float(FloatKind::Double),
             CXType_LongDouble => TypeKind::Float(FloatKind::LongDouble),
+            CXType_Float128 => TypeKind::Float(FloatKind::Float128),
             _ => return None,
         };
 
diff --git a/src/ir/ty.rs b/src/ir/ty.rs
index 57490cc2..4c2ef5d8 100644
--- a/src/ir/ty.rs
+++ b/src/ir/ty.rs
@@ -363,6 +363,8 @@ pub enum FloatKind {
     Double,
     /// A `long double`.
     LongDouble,
+    /// A `__float128`.
+    Float128,
 }
 
 /// The different kinds of types that we can parse.
@@ -819,7 +821,10 @@ impl Type {
                                            ctx);
             }
             _ => {
-                error!("unsupported type {:?} at {:?}", ty, location);
+                error!("unsupported type: kind = {:?}; ty = {:?}; at {:?}",
+                       ty.kind(),
+                       ty,
+                       location);
                 return Err(ParseError::Continue);
             }
         };