Index: include/llvm-c/Core.h
===================================================================
--- include/llvm-c/Core.h
+++ include/llvm-c/Core.h
@@ -415,6 +415,16 @@
     LLVMDSNote
 } LLVMDiagnosticSeverity;
 
+typedef enum {
+    LLVMFastMathFlagsNone = 0,  
+    LLVMFastMathFlagsAllowAlgebra,
+    LLVMFastMathFlagsNoNaN,
+    LLVMFastMathFlagsNoInf,
+    LLVMFastMathFlagsNoSignedZero,
+    LLVMFastMathFlagsAllowReciprocal
+} LLVMFastMathFlags;
+
+
 /**
  * @}
  */
@@ -2323,6 +2333,69 @@
  */
 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
 
+/**                                                                     
+ * Set the fast math flags in Dest for an individual instruction.       
+ *                                                                      
+ * This only returns something if concerned operator is a               
+ * FastMathoperator extension as frem, fadd, fdiv and fsub.             
+ *                                                                      
+ * @see llvm::Instruction::getFastMathFlags()                           
+ */
+void LLVMGetFastMathFlags(LLVMValueRef Inst, LLVMFastMathFlags* Dest);
+
+/**                                                                     
+ * Returns the number of fast math flags setting for an instruction.    
+ *                                                                      
+ * This only returns something if concerned operator is a               
+ * FastMathoperator extension as frem, fadd, fdiv and fsub.             
+ *                                                                      
+ */
+int LLVMCountFastMathFlags(LLVMValueRef Inst);
+
+/**                                                         
+ * Returns n != 0 if the individual instruction contains fast math flags.
+ *                                                          
+ * This only returns something if concerned operator is a   
+ * FastMathoperator extension as frem, fadd, fdiv and fsub.
+ *                                                          
+ * @see llvm::Instruction::hasUnsafeAlgebra()               
+ * @see llvm::Instruction::hasNoNans()                      
+ * @see llvm::Instruction::hasNoInfs()                      
+ * @see llvm::Instruction::hasNoSignedZeros()               
+ * @see llvm::Instruction::hasAllowReciproval()             
+ */
+int LLVMHasFastMathFlag(LLVMValueRef Inst, LLVMFastMathFlags FMF);
+
+/**                                                         
+ * Returns n != 0 if the individual instruction contains fast math flags.
+ *                                                          
+ * This only returns something if concerned operator is a   
+ * FastMathoperator extension as frem, fadd, fdiv and fsub.
+ *                                                          
+ * @see llvm::Instruction::hasUnsafeAlgebra()               
+ * @see llvm::Instruction::hasNoNans()                      
+ * @see llvm::Instruction::hasNoInfs()                      
+ * @see llvm::Instruction::hasNoSignedZeros()               
+ * @see llvm::Instruction::hasAllowReciproval()             
+ */
+int LLVMHasFastMathFlags(LLVMValueRef Inst);
+
+/**                                                         
+ * Set an uniq fast math flag on an individual instruction.
+ *                                                          
+ * This only returns something if concerned operator is a   
+ * FastMathoperator extension as frem, fadd, fdiv and fsub.
+ *                                              
+ * @see llvm::Instruction::setFastMathFlags()   
+ * @see llvm::Instruction::setUnsafeAlgebra()   
+ * @see llvm::Instruction::setNoNans()          
+ * @see llvm::Instruction::setNoInfs()          
+ * @see llvm::Instruction::setNoSignedZeros()   
+ * @see llvm::Instruction::setAllowReciproval()
+ * @see llvm::FastMathFlags::clear()            
+ */
+void LLVMSetFastMathFlag(LLVMValueRef Inst, LLVMFastMathFlags FMF);
+
 /**
  * Obtain the basic block to which an instruction belongs.
  *
Index: lib/IR/Core.cpp
===================================================================
--- lib/IR/Core.cpp
+++ lib/IR/Core.cpp
@@ -562,6 +562,104 @@
                                          MD ? unwrap<MDNode>(MD) : nullptr);
 }
 
+
+/*--... Operations on Fast Math operator ...................................--*/
+
+int LLVMHasFastMathFlags(LLVMValueRef Inst) {
+  return
+    (unwrap<Instruction>(Inst)->hasUnsafeAlgebra()
+     || unwrap<Instruction>(Inst)->hasNoNaNs()
+     || unwrap<Instruction>(Inst)->hasNoInfs()
+     || unwrap<Instruction>(Inst)->hasNoSignedZeros()
+     || unwrap<Instruction>(Inst)->hasAllowReciprocal());
+}
+
+
+int LLVMHasFastMathFlag(LLVMValueRef Inst, LLVMFastMathFlags Flag) {
+  switch(Flag){
+  case LLVMFastMathFlagsAllowAlgebra:
+    return unwrap<Instruction>(Inst)->hasUnsafeAlgebra();
+    break;
+  case LLVMFastMathFlagsNoNaN:
+    return unwrap<Instruction>(Inst)->hasNoNaNs();
+    break;
+  case LLVMFastMathFlagsNoInf:
+    return unwrap<Instruction>(Inst)->hasNoInfs();
+    break;
+  case LLVMFastMathFlagsNoSignedZero:
+    return unwrap<Instruction>(Inst)->hasNoSignedZeros();
+    break;
+  case LLVMFastMathFlagsAllowReciprocal:
+    return unwrap<Instruction>(Inst)->hasAllowReciprocal();
+    break;
+  default: return (LLVMHasFastMathFlags(Inst) == 0);
+    break;
+  }
+
+}
+
+void LLVMSetFastMathFlag(LLVMValueRef Inst, LLVMFastMathFlags Flag){
+  switch(Flag){
+  case LLVMFastMathFlagsAllowAlgebra:
+    unwrap<Instruction>(Inst)->setHasUnsafeAlgebra(true);
+    break;
+  case LLVMFastMathFlagsNoNaN:
+    unwrap<Instruction>(Inst)->setHasNoNaNs(true);
+    break;
+  case LLVMFastMathFlagsNoInf:
+    unwrap<Instruction>(Inst)->setHasNoInfs(true);
+    break;
+  case LLVMFastMathFlagsNoSignedZero:
+    unwrap<Instruction>(Inst)->setHasNoSignedZeros(true);
+    break;
+  case LLVMFastMathFlagsAllowReciprocal:
+    unwrap<Instruction>(Inst)->setHasAllowReciprocal(true);
+    break;
+  default: /* we suppose LLVMFastMathFlagsNone */
+    FastMathFlags fmf =
+      (unwrap<Instruction>(Inst)->getFastMathFlags());
+    fmf.clear();
+    unwrap<Instruction>(Inst)->setFastMathFlags(fmf);
+    break;
+  }
+}
+
+
+int LLVMCountFastMathFlags(LLVMValueRef Inst){
+  if (LLVMHasFastMathFlags(Inst) != 0) {
+    unsigned res = 0;
+    FastMathFlags fmf =
+      (unwrap<Instruction>(Inst)->getFastMathFlags());
+    if(fmf.noNaNs()) res++;
+    if(fmf.noInfs()) res++;
+    if(fmf.noSignedZeros()) res++;
+    if(fmf.allowReciprocal()) res++;
+    if(fmf.unsafeAlgebra()) res++;
+    return res;
+  }
+  return 0;
+}
+
+/* returns an array of FMF.t through Dest */
+void LLVMGetFastMathFlags(LLVMValueRef Inst, LLVMFastMathFlags* Dest){
+  if (LLVMHasFastMathFlags(Inst) != 0) {
+    unsigned i = 0;
+    FastMathFlags fmf =
+      (unwrap<Instruction>(Inst)->getFastMathFlags());
+    if(fmf.noNaNs())
+      Dest[i++] = (LLVMFastMathFlagsNoNaN);
+    if(fmf.noInfs())
+      Dest[i++] = (LLVMFastMathFlagsNoInf);
+    if(fmf.noSignedZeros())
+      Dest[i++] = (LLVMFastMathFlagsNoSignedZero);
+    if(fmf.allowReciprocal())
+      Dest[i++] = (LLVMFastMathFlagsAllowReciprocal);
+    if(fmf.unsafeAlgebra())
+      Dest[i++] = (LLVMFastMathFlagsAllowAlgebra);
+  }
+}
+
+
 /*--.. Conversion functions ................................................--*/
 
 #define LLVM_DEFINE_VALUE_CAST(name)                                       \