From bece8459c4c327bd4ae3dd6cf73e6ff16f0626ee Mon Sep 17 00:00:00 2001 From: Bruno LATHUILIERE Date: Mon, 16 Dec 2024 12:40:32 +0100 Subject: [PATCH] Add --unfused option (designed for fma) --- generateBackendInterOperator.py | 203 +- generateInstrumentOp_impl.py | 36 +- tests/.gitignore | 3 +- tests/Makefile.am | 10 +- tests/fma_common.hxx | 70 + tests/test_libm.cxx | 72 +- tests/test_unfusedfma.cxx | 113 + tests/test_unfusedfma1.stderr.exp | 59 + tests/test_unfusedfma1.stdout.exp | 65 + tests/test_unfusedfma1.vgtest | 4 + tests/test_unfusedfma2.stderr.exp | 60 + tests/test_unfusedfma2.stdout.exp | 65 + tests/test_unfusedfma2.vgtest | 4 + tests/test_unfusedfma3.stderr.exp | 59 + tests/test_unfusedfma3.stdout.exp | 65 + tests/test_unfusedfma3.vgtest | 4 + tests/test_unfusedfma4.stderr.exp | 60 + tests/test_unfusedfma4.stdout.exp | 65 + tests/test_unfusedfma4.vgtest | 5 + vr_clo.c | 5 + vr_generated_from_templates.h | 10324 ++++++++++++++-- vr_instrumentOp_impl.h | 24 +- vr_instrumentOp_impl_generated_all_backends.h | 88 + ...trumentOp_impl_generated_verrou_specific.h | 418 + vr_interp_operator_template_3args.h | 65 + vr_main.c | 3 + vr_main.h | 1 + 27 files changed, 10436 insertions(+), 1514 deletions(-) create mode 100644 tests/fma_common.hxx create mode 100644 tests/test_unfusedfma.cxx create mode 100644 tests/test_unfusedfma1.stderr.exp create mode 100644 tests/test_unfusedfma1.stdout.exp create mode 100644 tests/test_unfusedfma1.vgtest create mode 100644 tests/test_unfusedfma2.stderr.exp create mode 100644 tests/test_unfusedfma2.stdout.exp create mode 100644 tests/test_unfusedfma2.vgtest create mode 100644 tests/test_unfusedfma3.stderr.exp create mode 100644 tests/test_unfusedfma3.stdout.exp create mode 100644 tests/test_unfusedfma3.vgtest create mode 100644 tests/test_unfusedfma4.stderr.exp create mode 100644 tests/test_unfusedfma4.stdout.exp create mode 100644 tests/test_unfusedfma4.vgtest diff --git a/generateBackendInterOperator.py b/generateBackendInterOperator.py index b081371..1167716 100755 --- a/generateBackendInterOperator.py +++ b/generateBackendInterOperator.py @@ -27,6 +27,40 @@ import sys import re +FctNameRegExp=re.compile("(.*)FCTNAME\(([^,]*),([^)]*)\)(.*)") +FctConvNameRegExp=re.compile("(.*)FCTCONVNAME\(([^,]*),([^)]*)\)(.*)") +FctNameUnfusedRegExp=re.compile("(.*)FCTNAMEUNFUSED\(([^,]*),([^)]*)\)(.*)") +FctConvNameUnfusedRegExp=re.compile("(.*)FCTCONVNAMEUNFUSED\(([^,]*),([^)]*)\)(.*)") +BckNameRegExp=re.compile("(.*)BACKENDFUNC\(([^)]*)\)(.*)") +BckNameFirstRegExp=re.compile("(.*)BACKEND_FIRST_FUNC\(([^)]*)\)(.*)") +BckNameSecondRegExp=re.compile("(.*)BACKEND_SECOND_FUNC\(([^)]*)\)(.*)") +BckNameNearestRegExp=re.compile("(.*)BACKEND_NEAREST_FUNC\(([^)]*)\)(.*)") + + +def mergeFused(tab,tmpVar="res_temp"): + fusedTab=[] + for i in range(len(tab)): + line=tab[i] + if tmpVar+";" in line: + tab[i]= "//"+line + + if "_FIRST_" in line: + prefix=tab[0:max(0,i-1)] + first=tab[i] + second=tab[i+1] + postfix=tab[i+2:] + break + if not "_SECOND_" in second: + print("Generation failure") + return [line for line in prefix] + [mergeTwoLines(first,second, tmpVar)] +[line for line in postfix] + +def mergeTwoLines(first,second, varInter): + first=first.replace("_FIRST_","") + second=second.replace("_SECOND_","") + res=(first.partition("&"+varInter))[0] + (second.partition(varInter+","))[2] + return res + + def treatBackend(tab, soft): if soft==False: return tab @@ -34,24 +68,33 @@ def treatBackend(tab, soft): res=["if(vr.instrument_soft){\n"] res+=tab res+=["}else{\n"] - res+=[line.replace("BACKENDFUNC", "BACKEND_NEAREST_FUNC").replace("CONTEXT","BACKEND_NEAREST_CONTEXT") for line in tab] + if any(["BACKEND_FIRST" in line for line in tab]): + res+=mergeFused(tab) + else: + res+=[line.replace("BACKENDFUNC", "BACKEND_NEAREST_FUNC").replace("CONTEXT","BACKEND_NEAREST_CONTEXT") for line in tab] res+=["}\n"] return res -def transformTemplateForSoftStopStart(nameRegExp,convNameRegExp, - lineTab, soft=False, only64=False): +def transformTemplateForSoftStopStart(lineTab, soft=False, only64=False): func=[] dicOfFunc={} splitActive=False tab=[] for line in lineTab: - result=nameRegExp.match(line) #"(.*)FCTNAME\(([^,]*),([^)]*)\)(.*)") - if result!=None: - typeVal=result.group(2) - opt=result.group(3) - newName="FCTNAME("+typeVal+","+opt+")" + resultRegExp=None + for (FCTNAME, regExp) in [("FCTNAME", FctNameRegExp), + ("FCTCONVNAME", FctConvNameRegExp), + ("FCTNAMEUNFUSED", FctNameUnfusedRegExp), + ("FCTCONVNAMEUNFUSED", FctConvNameUnfusedRegExp)]: + resultRegExp=regExp.match(line) #"(.*)FCTNAME\(([^,]*),([^)]*)\)(.*)") + if resultRegExp!=None: + break + if resultRegExp!=None: + typeVal=resultRegExp.group(2) + opt=resultRegExp.group(3) + newName=FCTNAME+"("+typeVal+","+opt+")" if splitActive: dicOfFunc[currentName]=tab currentName=newName @@ -61,19 +104,6 @@ def transformTemplateForSoftStopStart(nameRegExp,convNameRegExp, splitActive=True currentName=newName - result=convNameRegExp.match(line) #"(.*)FCTCONVNAME\(([^,]*),([^)]*)\)(.*)") - if result!=None: - typeVal=result.group(2) - opt=result.group(3) - newName="FCTCONVNAME("+typeVal+","+opt+")" - if splitActive: - dicOfFunc[currentName]=tab - currentName=newName - tab=[line] - continue - else: - splitActive=True - currentName=newName if splitActive: tab+=[line] dicOfFunc[currentName]=tab @@ -92,7 +122,7 @@ def transformTemplateForSoftStopStart(nameRegExp,convNameRegExp, def transformTemplateForSoftStopStartOneFunction(lineTab, soft): res=[] back=[] - status="pre" + status="around" for line in lineTab: if "PREBACKEND" in line: status="back" @@ -100,9 +130,9 @@ def transformTemplateForSoftStopStartOneFunction(lineTab, soft): if "POSTBACKEND" in line: res+=treatBackend(back,soft) back=[] - status="pre" + status="around" continue - if status=="pre": + if status=="around": res+=[line] if status=="back": back+=[line] @@ -111,7 +141,6 @@ def transformTemplateForSoftStopStartOneFunction(lineTab, soft): def transformTemplateForSoftStopStartOneConvFunction(lineTabConv, lineTab, soft): if soft==False: return transformTemplateForSoftStopStartOneFunction(lineTabConv,soft) - res=[lineTabConv[0]] remain=lineTabConv[1:] while remain[-1].strip()!="}": @@ -128,12 +157,14 @@ def transformTemplateForSoftStopStartOneConvFunction(lineTabConv, lineTab, soft) remain=lineTab[1:] while remain[-1].strip()!="}": remain=remain[0:-1] - + elseInstrumentBock=[] for x in remain[0:-1]: if ("PREBACKEND" in x) or ("POSTBACKEND" in x): continue - res+=[x.replace("BACKENDFUNC", "BACKEND_NEAREST_FUNC").replace("CONTEXT","BACKEND_NEAREST_CONTEXT")] - + elseInstrumentBock+=[x] + if any(["BACKEND_FIRST" in line for line in elseInstrumentBock]): + elseInstrumentBock=mergeFused(elseInstrumentBock) + res+=[x.replace("BACKENDFUNC", "BACKEND_NEAREST_FUNC").replace("CONTEXT","BACKEND_NEAREST_CONTEXT") for x in elseInstrumentBock] res+=["}\n}\n\n"] return res @@ -144,13 +175,7 @@ def generateNargs(fileOut, fileNameTemplate, listOfBackend, listOfOp, nargs, pos commentConv=False templateStr=open(fileNameTemplate, "r").readlines() - FctNameRegExp=re.compile("(.*)FCTNAME\(([^,]*),([^)]*)\)(.*)") - FctConvNameRegExp=re.compile("(.*)FCTCONVNAME\(([^,]*),([^)]*)\)(.*)") - templateStr=transformTemplateForSoftStopStart(FctNameRegExp, FctConvNameRegExp, templateStr, soft, only64) - - BckNameRegExp=re.compile("(.*)BACKENDFUNC\(([^)]*)\)(.*)") - BckNameNearestRegExp=re.compile("(.*)BACKEND_NEAREST_FUNC\(([^)]*)\)(.*)") - + templateStr=transformTemplateForSoftStopStart(templateStr, soft, only64) if post in ["check_float_max"]: commentConv=True @@ -161,40 +186,52 @@ def generateNargs(fileOut, fileNameTemplate, listOfBackend, listOfOp, nargs, pos for op in listOfOp: for rounding in roundingTab: if nargs in [1,2]: - applyTemplate(fileOut, templateStr, FctNameRegExp, FctConvNameRegExp, BckNameRegExp, BckNameNearestRegExp, backend,op, post, sign=None, rounding=rounding, soft=soft, commentConv=commentConv) + applyTemplate(fileOut, templateStr, backend,op, post, sign=None, rounding=rounding, soft=soft, commentConv=commentConv) if nargs==3: sign="" if "msub" in op: sign="-" - applyTemplate(fileOut, templateStr, FctNameRegExp, FctConvNameRegExp, BckNameRegExp,BckNameNearestRegExp, backend, op, post, sign, rounding=rounding, soft=soft, commentConv=commentConv) + applyTemplate(fileOut, templateStr, backend, op, post, sign, rounding=rounding, soft=soft, commentConv=commentConv) if backend=="mcaquad": fileOut.write("#endif //USE_VERROU_QUADMATH\n") -def applyTemplate(fileOut, templateStr, FctRegExp, FctConvRegExp, BckRegExp, BckNearestRegExp, backend, op, post, sign=None, rounding=None, soft=False, commentConv=False): +def applyTemplate(fileOut, templateStr, backend, op, post, sign=None, rounding=None, soft=False, commentConv=False): fileOut.write("// generation of operation %s backend %s\n"%(op,backend)) backendFunc=backend if rounding!=None: backendFunc=backend+"_"+rounding - def fctName(conv,typeVal,opt): + def fctName(unfused,conv,typeVal,opt): vrPrefix="vr_" + if unfused: + vrPrefix+="unfused_" if conv: - vrPrefix="vr_conv_" + vrPrefix+="conv_" if soft: return vrPrefix+backendFunc+post+"_soft"+op+typeVal+opt else: return vrPrefix+backendFunc+post+op+typeVal+opt - def bckName(typeVal): - if sign!="-": - if rounding!=None: - return "interflop_"+backend+"_"+op+"_"+typeVal+"_"+rounding - return "interflop_"+backend+"_"+op+"_"+typeVal - else: - if rounding!=None: - return "interflop_"+backend+"_"+op.replace("sub","add")+"_"+typeVal+"_"+rounding - return "interflop_"+backend+"_"+op.replace("sub","add")+"_"+typeVal + def localOp(first): + localOp=op + if sign=="-": + localOp=op.replace("sub","add") + if op in ["madd","msub"] and first!=None: + if first==True: + localOp="mul" + if first==False: + if op=="madd": + localOp="add" + else: + localOp="sub" + return localOp + + def bckName(typeVal, first=None): + if rounding!=None: + return "interflop_"+backend+"_"+localOp(first)+"_"+typeVal+"_"+rounding + return "interflop_"+backend+"_"+localOp(first)+"_"+typeVal + def bckNearestName(typeVal): if rounding!=None: return (bckName(typeVal)).replace(rounding,"NEAREST") @@ -203,11 +240,11 @@ def bckNearestName(typeVal): else: return "interflop_verrou_"+op.replace("sub","add")+"_"+typeVal+"_NEAREST" - def bckNamePost(typeVal): - if sign!="-": - return "interflop_"+post+"_"+op+"_"+typeVal - else: - return "interflop_"+post+"_"+op.replace("sub","add")+"_"+typeVal + def bckNamePost(typeVal,first=None): + bop=localOp(first) + if bop in ["mul"] and post=="checkcancellation": + return None + return "interflop_"+post+"_"+bop+"_"+typeVal contextName="backend_"+backend+"_context" @@ -241,18 +278,13 @@ def outputRes(res,localComment): else: print("Generation failed") sys.exit() - result=FctRegExp.match(line) - if result!=None: - comment=False - typeVal=result.group(2) - opt=result.group(3) - if rounding=="NEAREST" and soft: - comment=True - res=result.group(1) + fctName(False,typeVal, opt) + result.group(4) - outputRes(res,comment) - continue - result=FctConvRegExp.match(line) + + result=FctConvNameRegExp.match(line) + fused=False + if result==None: + result=FctConvNameUnfusedRegExp.match(line) + fused=True if result!=None: if commentConv: comment=True @@ -260,20 +292,47 @@ def outputRes(res,localComment): comment=False typeVal=result.group(2) opt=result.group(3) - res=result.group(1) + fctName(True, typeVal, opt) + result.group(4) + res=result.group(1) + fctName(fused,True, typeVal, opt) + result.group(4) + outputRes(res,comment) + continue + + result=FctNameRegExp.match(line) + unfused=False + if result==None: + result=FctNameUnfusedRegExp.match(line) + unfused=True + if result!=None: + comment=False + typeVal=result.group(2) + opt=result.group(3) + if rounding=="NEAREST" and soft and (not unfused): + comment=True + res=result.group(1) + fctName(unfused,False,typeVal, opt) + result.group(4) outputRes(res,comment) continue - result=BckRegExp.match(line) + + result=None + first=None + for (rgExp,firstVar) in [(BckNameFirstRegExp, True), (BckNameSecondRegExp,False) , (BckNameRegExp,None)]: + result=rgExp.match(line) + if result!=None: + first=firstVar + break if result!=None: - res=result.group(1) + bckName(result.group(2)) + result.group(3) + group3=result.group(3) + if first==False: + group3=group3.replace(" - "," ") + res=result.group(1) + bckName(result.group(2),first) + group3 outputRes(res,comment) if post!="": - res=result.group(1) + bckNamePost(result.group(2)) + result.group(3) - res=res.replace(contextName, contextNamePost) - outputRes(res,comment) + bnPost=bckNamePost(result.group(2),first) + if bnPost!=None: + res=result.group(1) + bnPost+ group3 + res=res.replace(contextName, contextNamePost) + outputRes(res,comment) continue - result=BckNearestRegExp.match(line) + result=BckNameNearestRegExp.match(line) if result!=None: res=result.group(1) + bckNearestName(result.group(2)) + result.group(3) outputRes(res,comment) diff --git a/generateInstrumentOp_impl.py b/generateInstrumentOp_impl.py index 40021ec..052f507 100755 --- a/generateInstrumentOp_impl.py +++ b/generateInstrumentOp_impl.py @@ -5,24 +5,34 @@ includePatternHardWithoutConv=""" #define bcName(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP #define bcNameWithCC(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_ROUNDING"#OP, vr_unfused_verrou_ROUNDING##OP #define bcNameConv(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP #define bcNameConvWithCC(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_ROUNDING"#OP, vr_unfused_verrou_ROUNDING##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv -#undef bcNameConvWithCC""" +#undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused +""" includePatternHardWithConv=""" #define bcName(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP #define bcNameWithCC(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_ROUNDING"#OP, vr_unfused_verrou_ROUNDING##OP #define bcNameConv(OP) "vr_conv_verrou_ROUNDING"#OP, vr_conv_verrou_ROUNDING##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_ROUNDING"#OP, vr_conv_verrou_ROUNDING##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_ROUNDING"#OP, vr_unfused_conv_verrou_ROUNDING##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv -#undef bcNameConvWithCC""" +#undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused +""" floatConvPattern="""\tif(!vr.float_conv){%s\n\t}else{//vr.float_conv%s\n\t}//end float_conv\n""" @@ -31,47 +41,65 @@ includePatternSoftWithoutConv=""" #define bcName(OP) "vr_verrou_ROUNDING_soft"#OP, vr_verrou_ROUNDING_soft##OP #define bcNameWithCC(OP) "vr_verrou_ROUNDING_soft"#OP, vr_verrou_ROUNDING_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_ROUNDING_soft"#OP, vr_unfused_verrou_ROUNDING_soft##OP #define bcNameConv(OP) "vr_verrou_ROUNDING_soft"#OP, vr_verrou_ROUNDING_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_ROUNDING_soft"#OP, vr_verrou_ROUNDING_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_ROUNDING_soft"#OP, vr_unfused_verrou_ROUNDING_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv -#undef bcNameConvWithCC""" +#undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused +""" includePatternSoftWithConv=""" #define bcName(OP) "vr_verrou_ROUNDING_soft"#OP, vr_verrou_ROUNDING_soft##OP #define bcNameWithCC(OP) "vr_verrou_ROUNDING_soft"#OP, vr_verrou_ROUNDING_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_ROUNDING_soft"#OP, vr_unfused_verrou_ROUNDING_soft##OP #define bcNameConv(OP) "vr_conv_verrou_ROUNDING_soft"#OP, vr_conv_verrou_ROUNDING_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_ROUNDING_soft"#OP, vr_conv_verrou_ROUNDING_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_ROUNDING_soft"#OP, vr_unfused_conv_verrou_ROUNDING_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv -#undef bcNameConvWithCC""" +#undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused +""" includePatternSoft=floatConvPattern%(includePatternSoftWithoutConv, includePatternSoftWithConv) includePatternSoftNearest="""\tif(!vr.float_conv){ #define bcName(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP #define bcNameWithCC(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_ROUNDING_soft"#OP, vr_unfused_verrou_ROUNDING_soft##OP #define bcNameConv(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP #define bcNameConvWithCC(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_ROUNDING_soft"#OP, vr_unfused_verrou_ROUNDING_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused \t}else{//vr.float_conv #define bcName(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP #define bcNameWithCC(OP) "vr_verrou_ROUNDING"#OP, vr_verrou_ROUNDING##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_ROUNDING_soft"#OP, vr_unfused_verrou_ROUNDING_soft##OP #define bcNameConv(OP) "vr_conv_verrou_ROUNDING_soft"#OP, vr_conv_verrou_ROUNDING_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_ROUNDING_soft"#OP, vr_conv_verrou_ROUNDING_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_ROUNDING_soft"#OP, vr_unfused_conv_verrou_ROUNDING_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused \t}//end float_conv """ diff --git a/tests/.gitignore b/tests/.gitignore index c4df46a..f2980d1 100644 --- a/tests/.gitignore +++ b/tests/.gitignore @@ -11,4 +11,5 @@ test_det test_libm clreq sum -libmtest_float_conv \ No newline at end of file +libmtest_float_conv +test_unfusedfma \ No newline at end of file diff --git a/tests/Makefile.am b/tests/Makefile.am index 04c14f6..435aaec 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -44,7 +44,11 @@ EXTRA_DIST = \ hardSoftClreqDouble2.stderr.exp hardSoftClreqDouble2.stdout.exp hardSoftClreqDouble2.vgtest \ hardSoftClreqDouble3.stderr.exp hardSoftClreqDouble3.stdout.exp hardSoftClreqDouble3.vgtest \ libmtest_float_conv1.stderr.exp libmtest_float_conv1.stdout.exp libmtest_float_conv1.vgtest libmtest_float_conv1.stderr.exp.aarch64 \ - libmtest_float_conv2.stderr.exp libmtest_float_conv2.stdout.exp libmtest_float_conv2.vgtest libmtest_float_conv2.stderr.exp.aarch64 + libmtest_float_conv2.stderr.exp libmtest_float_conv2.stdout.exp libmtest_float_conv2.vgtest libmtest_float_conv2.stderr.exp.aarch64 \ + test_unfusedfma1.stderr.exp test_unfusedfma1.stdout.exp test_unfusedfma1.vgtest \ + test_unfusedfma2.stderr.exp test_unfusedfma2.stdout.exp test_unfusedfma2.vgtest \ + test_unfusedfma3.stderr.exp test_unfusedfma3.stdout.exp test_unfusedfma3.vgtest \ + test_unfusedfma4.stderr.exp test_unfusedfma4.stdout.exp test_unfusedfma4.vgtest check_PROGRAMS = clreq accuClreq sum libmtest hardSoftClreq hardSoftClreqDouble libmtest_float_conv @@ -54,10 +58,10 @@ naninf_SOURCES = naninf.cxx check_PROGRAMS += denorm denorm_SOURCES = denorm.cxx -check_PROGRAMS += test_det test_libm +check_PROGRAMS += test_det test_libm test_unfusedfma test_det_SOURCES = test_det.cxx test_libm_SOURCES = test_libm.cxx - +test_unfusedfma_SOURCES = test_unfusedfma.cxx VERROU_FLAG = -O0 -g3 -fno-builtin @vg_test_no_avx512f_flag@ if HAVE_VERROU_FMA_INTRIN diff --git a/tests/fma_common.hxx b/tests/fma_common.hxx new file mode 100644 index 0000000..515d72a --- /dev/null +++ b/tests/fma_common.hxx @@ -0,0 +1,70 @@ +#pragma once +#if defined(VGA_amd64) || defined(__x86_64__) +#include +#endif + +#if defined(VGA_arm64) || defined(__aarch64__) +#include "arm_neon.h" +#endif + + +template +inline REALTYPE intrin_fma(const REALTYPE&, const REALTYPE&, const REALTYPE&); + +#if defined(__x86_64__) +template<> +inline double intrin_fma(const double& a, const double& b, const double& c){ + double d; + __m128d ai, bi,ci,di; + ai = _mm_load_sd(&a); + bi = _mm_load_sd(&b); + ci = _mm_load_sd(&c); + di=_mm_fmadd_sd(ai,bi,ci); + d=_mm_cvtsd_f64(di); + return d; +} +#endif + +#if defined(__aarch64__) +template<> +inline double intrin_fma(const double& a, const double& b, const double& c){ + double d; + const float64x1_t ai=vld1_f64(&a); + const float64x1_t bi=vld1_f64(&b); + const float64x1_t ci=vld1_f64(&c); + + const float64x1_t di=vfma_f64(ci,ai,bi);// warning strange argument order + // cf doc : https://developer.arm.com/architectures/instruction-set/intrinsics/#q=vfma + vst1_f64(&d, di); + return d; +} +#endif + + + +#if defined(__x86_64__) +template<> +inline float intrin_fma(const float& a, const float& b, const float& c){ + float d; + __m128 ai, bi,ci,di; + ai = _mm_load_ss(&a); + bi = _mm_load_ss(&b); + ci = _mm_load_ss(&c); + di=_mm_fmadd_ss(ai,bi,ci); + d=_mm_cvtss_f32(di); + return d; +} +#endif + + +#if defined(__aarch64__) +template<> +inline float intrin_fma(const float& a, const float& b, const float& c){ + float res; + __asm__( + "fmadd %s0, %s1, %s2, %s3": + "=x"(res): "x"(a),"x"(b),"x"(c) + ); + return res; +} +#endif diff --git a/tests/test_libm.cxx b/tests/test_libm.cxx index 9805df3..8780368 100644 --- a/tests/test_libm.cxx +++ b/tests/test_libm.cxx @@ -7,77 +7,7 @@ #include //#include "../interflop_backends/interflop_verrou/vr_fma.hxx" - -#if defined(VGA_amd64) || defined(__x86_64__) -#include -#endif - -#if defined(VGA_arm64) || defined(__aarch64__) -#include "arm_neon.h" -#endif - - -template -inline REALTYPE intrin_fma(const REALTYPE&, const REALTYPE&, const REALTYPE&); - -#if defined(__x86_64__) -template<> -inline double intrin_fma(const double& a, const double& b, const double& c){ - double d; - __m128d ai, bi,ci,di; - ai = _mm_load_sd(&a); - bi = _mm_load_sd(&b); - ci = _mm_load_sd(&c); - di=_mm_fmadd_sd(ai,bi,ci); - d=_mm_cvtsd_f64(di); - return d; -} -#endif - -#if defined(__aarch64__) -template<> -inline double intrin_fma(const double& a, const double& b, const double& c){ - double d; - const float64x1_t ai=vld1_f64(&a); - const float64x1_t bi=vld1_f64(&b); - const float64x1_t ci=vld1_f64(&c); - - const float64x1_t di=vfma_f64(ci,ai,bi);// warning strange argument order - // cf doc : https://developer.arm.com/architectures/instruction-set/intrinsics/#q=vfma - vst1_f64(&d, di); - return d; -} -#endif - - - -#if defined(__x86_64__) -template<> -inline float intrin_fma(const float& a, const float& b, const float& c){ - float d; - __m128 ai, bi,ci,di; - ai = _mm_load_ss(&a); - bi = _mm_load_ss(&b); - ci = _mm_load_ss(&c); - di=_mm_fmadd_ss(ai,bi,ci); - d=_mm_cvtss_f32(di); - return d; -} -#endif - - -#if defined(__aarch64__) -template<> -inline float intrin_fma(const float& a, const float& b, const float& c){ - float res; - __asm__( - "fmadd %s0, %s1, %s2, %s3": - "=x"(res): "x"(a),"x"(b),"x"(c) - ); - return res; -} -#endif - +#include "fma_common.hxx" size_t loopNumber=16; diff --git a/tests/test_unfusedfma.cxx b/tests/test_unfusedfma.cxx new file mode 100644 index 0000000..9deaba2 --- /dev/null +++ b/tests/test_unfusedfma.cxx @@ -0,0 +1,113 @@ +#include "../verrou.h" +#include +#include +#include +#include +#include +#include "fma_common.hxx" + +double a=0.1,b=0.1,c=-0.01; +float a_f=(float)a; +float b_f=(float)b; +float c_f=(float)c; + + +double ref_unfused; +double ref_fused; +float ref_unfused_f; +float ref_fused_f; +double unfused; +double fused; +float unfused_f; +float fused_f; + +void computeRef(){ + ref_unfused=a*b+c; + ref_fused=intrin_fma(a,b,c); + + ref_unfused_f=a_f*b_f+c_f; + ref_fused_f=intrin_fma(a_f,b_f,c_f); +} + +template +std::string equal(T1& x,T2& y){ + if(x==y){ + return std::string("=="); + }else{ + return std::string("!="); + } +} + +void compute(){ + unfused=a*b+c; + fused=intrin_fma(a,b,c); + + unfused_f=a_f*b_f+c_f; + fused_f=intrin_fma(a_f,b_f,c_f); + + std::cout << "fused" << equal(fused, unfused)<<"unfused"< float +Frontend: unfused +Backend verrou simulating NEAREST rounding mode +EXCLUDE DETECTED: XXXXX +EXCLUDE DETECTED: XXXXX +Using exclusion rule: * XXXXX +Using exclusion rule: * XXXXX + + --------------------------------------------------------------------- + Operation Instruction count + `- Precision + `- Vectorization Total Instrumented + --------------------------------------------------------------------- + add 22 8 ( 36%) + `- flt 11 4 ( 36%) + `- llo 11 4 ( 36%) + `- dbl 11 4 ( 36%) + `- llo 11 4 ( 36%) + --------------------------------------------------------------------- + mul 22 8 ( 36%) + `- flt 11 4 ( 36%) + `- llo 11 4 ( 36%) + `- dbl 11 4 ( 36%) + `- llo 11 4 ( 36%) + --------------------------------------------------------------------- + mAdd 22 8 ( 36%) + `- flt 11 4 ( 36%) + `- dbl 11 4 ( 36%) + --------------------------------------------------------------------- +ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) diff --git a/tests/test_unfusedfma2.stdout.exp b/tests/test_unfusedfma2.stdout.exp new file mode 100644 index 0000000..d2836f8 --- /dev/null +++ b/tests/test_unfusedfma2.stdout.exp @@ -0,0 +1,65 @@ +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +inst +fused==unfused +fused_f==unfused_f +fused==fused_f +unfused==unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +inst +fused==unfused +fused_f==unfused_f +fused==fused_f +unfused==unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +inst +fused==unfused +fused_f==unfused_f +fused==fused_f +unfused==unfused_f + +inst +fused==unfused +fused_f==unfused_f +fused==fused_f +unfused==unfused_f + diff --git a/tests/test_unfusedfma2.vgtest b/tests/test_unfusedfma2.vgtest new file mode 100644 index 0000000..f0d3566 --- /dev/null +++ b/tests/test_unfusedfma2.vgtest @@ -0,0 +1,4 @@ +prog: test_unfusedfma +args: +vgopts: --instr-atstart-soft=no --unfused=yes --float=yes +stderr_filter_args: -cnt-cmp-conv -backend-version -copyright -exclude -seed -scal-llo diff --git a/tests/test_unfusedfma3.stderr.exp b/tests/test_unfusedfma3.stderr.exp new file mode 100644 index 0000000..e711ca3 --- /dev/null +++ b/tests/test_unfusedfma3.stderr.exp @@ -0,0 +1,59 @@ +Verrou, Check floating-point rounding errors +Copyright (C) XXXXX + +First seed : XXX +Backend verrou : test-version +Backend checkcancellation : test-version +Backend check_float_max : test-version +Backend checkdenorm : test-version +Instrumented operations : + add : yes + sub : yes + mul : yes + div : yes + mAdd : yes + mSub : yes + sqrt : yes + cmp : no + conv : yes + max : no + min : no +Instrumented vectorized operations : + scal : no + llo : yes + vec2 : yes + vec4 : yes + vec8 : yes + unk : yes +Instrumented type : + flt : yes + dbl : yes +Frontend: double -> float +Backend verrou simulating NEAREST rounding mode +EXCLUDE DETECTED: XXXXX +EXCLUDE DETECTED: XXXXX +Using exclusion rule: * XXXXX +Using exclusion rule: * XXXXX + + --------------------------------------------------------------------- + Operation Instruction count + `- Precision + `- Vectorization Total Instrumented + --------------------------------------------------------------------- + add 22 10 ( 45%) + `- flt 11 5 ( 45%) + `- llo 11 5 ( 45%) + `- dbl 11 5 ( 45%) + `- llo 11 5 ( 45%) + --------------------------------------------------------------------- + mul 22 10 ( 45%) + `- flt 11 5 ( 45%) + `- llo 11 5 ( 45%) + `- dbl 11 5 ( 45%) + `- llo 11 5 ( 45%) + --------------------------------------------------------------------- + mAdd 22 10 ( 45%) + `- flt 11 5 ( 45%) + `- dbl 11 5 ( 45%) + --------------------------------------------------------------------- +ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) diff --git a/tests/test_unfusedfma3.stdout.exp b/tests/test_unfusedfma3.stdout.exp new file mode 100644 index 0000000..cd2e18c --- /dev/null +++ b/tests/test_unfusedfma3.stdout.exp @@ -0,0 +1,65 @@ +fused!=unfused +fused_f!=unfused_f +fused==fused_f +unfused==unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +inst +fused!=unfused +fused_f!=unfused_f +fused==fused_f +unfused==unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +inst +fused!=unfused +fused_f!=unfused_f +fused==fused_f +unfused==unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +inst +fused!=unfused +fused_f!=unfused_f +fused==fused_f +unfused==unfused_f + +inst +fused!=unfused +fused_f!=unfused_f +fused==fused_f +unfused==unfused_f + diff --git a/tests/test_unfusedfma3.vgtest b/tests/test_unfusedfma3.vgtest new file mode 100644 index 0000000..cd7b603 --- /dev/null +++ b/tests/test_unfusedfma3.vgtest @@ -0,0 +1,4 @@ +prog: test_unfusedfma +args: +vgopts: --float=yes +stderr_filter_args: -cnt-cmp-conv -backend-version -copyright -exclude -seed -scal-llo diff --git a/tests/test_unfusedfma4.stderr.exp b/tests/test_unfusedfma4.stderr.exp new file mode 100644 index 0000000..35012ad --- /dev/null +++ b/tests/test_unfusedfma4.stderr.exp @@ -0,0 +1,60 @@ +Verrou, Check floating-point rounding errors +Copyright (C) XXXXX + +First seed : XXX +Backend verrou : test-version +Backend checkcancellation : test-version +Backend check_float_max : test-version +Backend checkdenorm : test-version +Instrumented operations : + add : yes + sub : yes + mul : yes + div : yes + mAdd : yes + mSub : yes + sqrt : yes + cmp : no + conv : no + max : no + min : no +Instrumented vectorized operations : + scal : no + llo : yes + vec2 : yes + vec4 : yes + vec8 : yes + unk : yes +Instrumented type : + flt : yes + dbl : yes +Frontend: double -> float +Frontend: unfused +Backend verrou simulating RANDOM_DET rounding mode +EXCLUDE DETECTED: XXXXX +EXCLUDE DETECTED: XXXXX +Using exclusion rule: * XXXXX +Using exclusion rule: * XXXXX + + --------------------------------------------------------------------- + Operation Instruction count + `- Precision + `- Vectorization Total Instrumented + --------------------------------------------------------------------- + add 22 10 ( 45%) + `- flt 11 5 ( 45%) + `- llo 11 5 ( 45%) + `- dbl 11 5 ( 45%) + `- llo 11 5 ( 45%) + --------------------------------------------------------------------- + mul 22 10 ( 45%) + `- flt 11 5 ( 45%) + `- llo 11 5 ( 45%) + `- dbl 11 5 ( 45%) + `- llo 11 5 ( 45%) + --------------------------------------------------------------------- + mAdd 22 10 ( 45%) + `- flt 11 5 ( 45%) + `- dbl 11 5 ( 45%) + --------------------------------------------------------------------- +ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) diff --git a/tests/test_unfusedfma4.stdout.exp b/tests/test_unfusedfma4.stdout.exp new file mode 100644 index 0000000..33da8fe --- /dev/null +++ b/tests/test_unfusedfma4.stdout.exp @@ -0,0 +1,65 @@ +fused==unfused +fused_f==unfused_f +fused==fused_f +unfused==unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +inst +fused==unfused +fused_f==unfused_f +fused==fused_f +unfused==unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +inst +fused==unfused +fused_f==unfused_f +fused==fused_f +unfused==unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +non inst +fused!=unfused +fused_f!=unfused_f +fused!=fused_f +unfused!=unfused_f + +inst +fused==unfused +fused_f==unfused_f +fused==fused_f +unfused==unfused_f + +inst +fused==unfused +fused_f==unfused_f +fused==fused_f +unfused==unfused_f + diff --git a/tests/test_unfusedfma4.vgtest b/tests/test_unfusedfma4.vgtest new file mode 100644 index 0000000..5426cc2 --- /dev/null +++ b/tests/test_unfusedfma4.vgtest @@ -0,0 +1,5 @@ +prog: test_unfusedfma +args: +vgopts: --float=yes --unfused=yes --rounding-mode=random_det --vr-seed=42 --vr-instr=add,sub,mul,mAdd,mSub,sqrt,div +#vr-instr is there to avoid randomness in cast used to defined a_f +stderr_filter_args: -cnt-cmp-conv -backend-version -copyright -exclude -seed -scal-llo diff --git a/vr_clo.c b/vr_clo.c index 961fd20..86151c4 100644 --- a/vr_clo.c +++ b/vr_clo.c @@ -48,6 +48,7 @@ void vr_env_clo_one_option (const HChar* env, const HChar *clo) { void vr_env_clo(void){ vr_env_clo_one_option("VERROU_ROUNDING_MODE", "--rounding-mode"); vr_env_clo_one_option("VERROU_FLOAT", "--float"); + vr_env_clo_one_option("VERROU_UNFUSED", "--unfused"); vr_env_clo_one_option("VERROU_LIBM_NOINST_ROUNDING_MODE", "--libm-noinst-rounding-mode"); vr_env_clo_one_option("VERROU_PRANDOM_UPDATE", "--prandom-update"); vr_env_clo_one_option("VERROU_PRANDOM_PVALUE", "--prandom-pvalue"); @@ -87,6 +88,7 @@ void vr_clo_defaults (void) { vr.count = True; vr.float_conv=False; + vr.unfused=False; vr.instrument_hard = VR_INSTR_ON; vr.instrument_soft = VR_INSTR_ON; vr.instrument_soft_used = False; @@ -237,6 +239,9 @@ Bool vr_process_clo (const HChar *arg) { else if (VG_BOOL_CLOM (cloPD, arg, "--float", bool_val)) { vr.float_conv = bool_val; } + else if (VG_BOOL_CLOM (cloPD, arg, "--unfused", bool_val)) { + vr.unfused = bool_val; + } //Option mcaquad else if (VG_INT_CLOM (cloPD, arg, "--mca-precision-double", diff --git a/vr_generated_from_templates.h b/vr_generated_from_templates.h index 85c18f7..a59edd1 100644 --- a/vr_generated_from_templates.h +++ b/vr_generated_from_templates.h @@ -36952,14 +36952,18 @@ static VG_REGPARM(3) Int vr_verroumadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verroumsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verroumadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + double res_temp; + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double(res_temp, *arg3, &res, backend_verrou_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -36968,7 +36972,7 @@ static VG_REGPARM(3) Long vr_verroumsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verroumsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verroumadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -36979,7 +36983,9 @@ static VG_REGPARM(3) Long vr_conv_verroumsub64F (Long a, Long b, Long c) { double res; float resf; - interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -36989,14 +36995,15 @@ static VG_REGPARM(3) Long vr_conv_verroumsub64F (Long a, Long b, Long c) { return *d; } - -static VG_REGPARM(3) Int vr_verroumsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verroumadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float(res_temp, *arg3, &res, backend_verrou_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37004,15 +37011,14 @@ static VG_REGPARM(3) Int vr_verroumsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -#ifdef USE_VERROU_QUADMATH -// generation of operation madd backend mcaquad -static VG_REGPARM(3) Long vr_mcaquadmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verroumsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_mcaquad_madd_double(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); + interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37021,7 +37027,7 @@ static VG_REGPARM(3) Long vr_mcaquadmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_mcaquadmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verroumsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37032,7 +37038,7 @@ static VG_REGPARM(3) Long vr_conv_mcaquadmadd64F (Long a, Long b, Long c) { double res; float resf; - interflop_mcaquad_madd_float(arg1f, arg2f, arg3f, &resf, backend_mcaquad_context); + interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -37043,13 +37049,13 @@ static VG_REGPARM(3) Long vr_conv_mcaquadmadd64F (Long a, Long b, Long c) { } -static VG_REGPARM(3) Int vr_mcaquadmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verroumsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_mcaquad_madd_float(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); + interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37057,14 +37063,18 @@ static VG_REGPARM(3) Int vr_mcaquadmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend mcaquad -static VG_REGPARM(3) Long vr_mcaquadmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verroumsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_mcaquad_madd_double(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); + double res_temp; + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double(res_temp, *arg3, &res, backend_verrou_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37073,7 +37083,7 @@ static VG_REGPARM(3) Long vr_mcaquadmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_mcaquadmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verroumsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37084,7 +37094,9 @@ static VG_REGPARM(3) Long vr_conv_mcaquadmsub64F (Long a, Long b, Long c) { double res; float resf; - interflop_mcaquad_madd_float(arg1f, arg2f, - arg3f, &resf, backend_mcaquad_context); + float res_temp; + interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -37094,14 +37106,15 @@ static VG_REGPARM(3) Long vr_conv_mcaquadmsub64F (Long a, Long b, Long c) { return *d; } - -static VG_REGPARM(3) Int vr_mcaquadmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verroumsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_mcaquad_madd_float(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); + float res_temp; + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float(res_temp, *arg3, &res, backend_verrou_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37109,15 +37122,15 @@ static VG_REGPARM(3) Int vr_mcaquadmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -#endif //USE_VERROU_QUADMATH -// generation of operation madd backend checkdenorm -static VG_REGPARM(3) Long vr_checkdenormmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_QUADMATH +// generation of operation madd backend mcaquad +static VG_REGPARM(3) Long vr_mcaquadmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_checkdenorm_madd_double(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); + interflop_mcaquad_madd_double(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37126,7 +37139,7 @@ static VG_REGPARM(3) Long vr_checkdenormmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_checkdenormmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_mcaquadmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37137,7 +37150,7 @@ static VG_REGPARM(3) Long vr_conv_checkdenormmadd64F (Long a, Long b, Long c) { double res; float resf; - interflop_checkdenorm_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkdenorm_context); + interflop_mcaquad_madd_float(arg1f, arg2f, arg3f, &resf, backend_mcaquad_context); res=resf; #else double res=0.; @@ -37148,13 +37161,13 @@ static VG_REGPARM(3) Long vr_conv_checkdenormmadd64F (Long a, Long b, Long c) { } -static VG_REGPARM(3) Int vr_checkdenormmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_mcaquadmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_checkdenorm_madd_float(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); + interflop_mcaquad_madd_float(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37162,14 +37175,18 @@ static VG_REGPARM(3) Int vr_checkdenormmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend checkdenorm -static VG_REGPARM(3) Long vr_checkdenormmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_mcaquadmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_checkdenorm_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); + double res_temp; + interflop_mcaquad_mul_double(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_double(res_temp, *arg3, &res, backend_mcaquad_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37178,7 +37195,7 @@ static VG_REGPARM(3) Long vr_checkdenormmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_checkdenormmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_mcaquadmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37189,7 +37206,9 @@ static VG_REGPARM(3) Long vr_conv_checkdenormmsub64F (Long a, Long b, Long c) { double res; float resf; - interflop_checkdenorm_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkdenorm_context); + float res_temp; + interflop_mcaquad_mul_float(arg1f, arg2f, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_float(res_temp, arg3f, &resf, backend_mcaquad_context); res=resf; #else double res=0.; @@ -37199,14 +37218,15 @@ static VG_REGPARM(3) Long vr_conv_checkdenormmsub64F (Long a, Long b, Long c) { return *d; } - -static VG_REGPARM(3) Int vr_checkdenormmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_mcaquadmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_checkdenorm_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); + float res_temp; + interflop_mcaquad_mul_float(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_float(res_temp, *arg3, &res, backend_mcaquad_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37214,18 +37234,14 @@ static VG_REGPARM(3) Int vr_checkdenormmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend mcaquad +static VG_REGPARM(3) Long vr_mcaquadmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; -if(vr.instrument_soft){ - interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); -}else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); -} + interflop_mcaquad_madd_double(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37234,8 +37250,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_softmadd64F (Long a, Long b, Long c) { -if(vr.instrument_soft){ +static VG_REGPARM(3) Long vr_conv_mcaquadmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37246,7 +37261,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_mcaquad_madd_float(arg1f, arg2f, - arg3f, &resf, backend_mcaquad_context); res=resf; #else double res=0.; @@ -37254,33 +37269,16 @@ if(vr.instrument_soft){ #endif Long *d = (Long*)(&res); return *d; -}else{ -#ifdef USE_VERROU_FMA - double *arg1 = (double*)(&a); - double *arg2 = (double*)(&b); - double *arg3 = (double*)(&c); - double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); -#else - double res=0.; - VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); -#endif - Long *d = (Long*)(&res); - return *d; -} } -static VG_REGPARM(3) Int vr_verrou_softmadd32F (Long a, Long b, Long c) { + +static VG_REGPARM(3) Int vr_mcaquadmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; -if(vr.instrument_soft){ - interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); -}else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); -} + interflop_mcaquad_madd_float(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37288,18 +37286,18 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_mcaquadmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; -if(vr.instrument_soft){ - interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); -}else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + double res_temp; + interflop_mcaquad_mul_double(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_double(res_temp, *arg3, &res, backend_mcaquad_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37308,8 +37306,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_softmsub64F (Long a, Long b, Long c) { -if(vr.instrument_soft){ +static VG_REGPARM(3) Long vr_unfused_conv_mcaquadmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37320,7 +37317,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_mcaquad_mul_float(arg1f, arg2f, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_float(res_temp, arg3f, &resf, backend_mcaquad_context); res=resf; #else double res=0.; @@ -37328,33 +37327,17 @@ if(vr.instrument_soft){ #endif Long *d = (Long*)(&res); return *d; -}else{ -#ifdef USE_VERROU_FMA - double *arg1 = (double*)(&a); - double *arg2 = (double*)(&b); - double *arg3 = (double*)(&c); - double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -#else - double res=0.; - VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); -#endif - Long *d = (Long*)(&res); - return *d; -} } -static VG_REGPARM(3) Int vr_verrou_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_mcaquadmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; -if(vr.instrument_soft){ - interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); -}else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + float res_temp; + interflop_mcaquad_mul_float(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_float(res_temp, *arg3, &res, backend_mcaquad_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37362,19 +37345,15 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -#ifdef USE_VERROU_QUADMATH -// generation of operation madd backend mcaquad -static VG_REGPARM(3) Long vr_mcaquad_softmadd64F (Long a, Long b, Long c) { +#endif //USE_VERROU_QUADMATH +// generation of operation madd backend checkdenorm +static VG_REGPARM(3) Long vr_checkdenormmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; -if(vr.instrument_soft){ - interflop_mcaquad_madd_double(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); -}else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); -} + interflop_checkdenorm_madd_double(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37383,8 +37362,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_mcaquad_softmadd64F (Long a, Long b, Long c) { -if(vr.instrument_soft){ +static VG_REGPARM(3) Long vr_conv_checkdenormmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37395,7 +37373,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_mcaquad_madd_float(arg1f, arg2f, arg3f, &resf, backend_mcaquad_context); + interflop_checkdenorm_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkdenorm_context); res=resf; #else double res=0.; @@ -37403,33 +37381,16 @@ if(vr.instrument_soft){ #endif Long *d = (Long*)(&res); return *d; -}else{ -#ifdef USE_VERROU_FMA - double *arg1 = (double*)(&a); - double *arg2 = (double*)(&b); - double *arg3 = (double*)(&c); - double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); -#else - double res=0.; - VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); -#endif - Long *d = (Long*)(&res); - return *d; -} } -static VG_REGPARM(3) Int vr_mcaquad_softmadd32F (Long a, Long b, Long c) { + +static VG_REGPARM(3) Int vr_checkdenormmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; -if(vr.instrument_soft){ - interflop_mcaquad_madd_float(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); -}else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); -} + interflop_checkdenorm_madd_float(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37437,18 +37398,18 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend mcaquad -static VG_REGPARM(3) Long vr_mcaquad_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_checkdenormmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; -if(vr.instrument_soft){ - interflop_mcaquad_madd_double(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); -}else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + double res_temp; + interflop_checkdenorm_mul_double(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_double(res_temp, *arg3, &res, backend_checkdenorm_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37457,8 +37418,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_mcaquad_softmsub64F (Long a, Long b, Long c) { -if(vr.instrument_soft){ +static VG_REGPARM(3) Long vr_unfused_conv_checkdenormmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37469,7 +37429,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_mcaquad_madd_float(arg1f, arg2f, - arg3f, &resf, backend_mcaquad_context); + float res_temp; + interflop_checkdenorm_mul_float(arg1f, arg2f, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_float(res_temp, arg3f, &resf, backend_checkdenorm_context); res=resf; #else double res=0.; @@ -37477,33 +37439,17 @@ if(vr.instrument_soft){ #endif Long *d = (Long*)(&res); return *d; -}else{ -#ifdef USE_VERROU_FMA - double *arg1 = (double*)(&a); - double *arg2 = (double*)(&b); - double *arg3 = (double*)(&c); - double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -#else - double res=0.; - VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); -#endif - Long *d = (Long*)(&res); - return *d; -} } -static VG_REGPARM(3) Int vr_mcaquad_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_checkdenormmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; -if(vr.instrument_soft){ - interflop_mcaquad_madd_float(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); -}else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + float res_temp; + interflop_checkdenorm_mul_float(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_float(res_temp, *arg3, &res, backend_checkdenorm_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37511,19 +37457,14 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -#endif //USE_VERROU_QUADMATH -// generation of operation madd backend checkdenorm -static VG_REGPARM(3) Long vr_checkdenorm_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend checkdenorm +static VG_REGPARM(3) Long vr_checkdenormmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; -if(vr.instrument_soft){ - interflop_checkdenorm_madd_double(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); -}else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); -} + interflop_checkdenorm_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37532,8 +37473,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_checkdenorm_softmadd64F (Long a, Long b, Long c) { -if(vr.instrument_soft){ +static VG_REGPARM(3) Long vr_conv_checkdenormmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37544,7 +37484,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_checkdenorm_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkdenorm_context); + interflop_checkdenorm_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkdenorm_context); res=resf; #else double res=0.; @@ -37552,33 +37492,16 @@ if(vr.instrument_soft){ #endif Long *d = (Long*)(&res); return *d; -}else{ -#ifdef USE_VERROU_FMA - double *arg1 = (double*)(&a); - double *arg2 = (double*)(&b); - double *arg3 = (double*)(&c); - double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); -#else - double res=0.; - VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); -#endif - Long *d = (Long*)(&res); - return *d; -} } -static VG_REGPARM(3) Int vr_checkdenorm_softmadd32F (Long a, Long b, Long c) { + +static VG_REGPARM(3) Int vr_checkdenormmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; -if(vr.instrument_soft){ - interflop_checkdenorm_madd_float(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); -}else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); -} + interflop_checkdenorm_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37586,18 +37509,18 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend checkdenorm -static VG_REGPARM(3) Long vr_checkdenorm_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_checkdenormmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; -if(vr.instrument_soft){ - interflop_checkdenorm_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); -}else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + double res_temp; + interflop_checkdenorm_mul_double(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_double(res_temp, *arg3, &res, backend_checkdenorm_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37606,8 +37529,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_checkdenorm_softmsub64F (Long a, Long b, Long c) { -if(vr.instrument_soft){ +static VG_REGPARM(3) Long vr_unfused_conv_checkdenormmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37618,7 +37540,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_checkdenorm_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkdenorm_context); + float res_temp; + interflop_checkdenorm_mul_float(arg1f, arg2f, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_float(res_temp, arg3f, &resf, backend_checkdenorm_context); res=resf; #else double res=0.; @@ -37626,33 +37550,17 @@ if(vr.instrument_soft){ #endif Long *d = (Long*)(&res); return *d; -}else{ -#ifdef USE_VERROU_FMA - double *arg1 = (double*)(&a); - double *arg2 = (double*)(&b); - double *arg3 = (double*)(&c); - double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -#else - double res=0.; - VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); -#endif - Long *d = (Long*)(&res); - return *d; -} } -static VG_REGPARM(3) Int vr_checkdenorm_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_checkdenormmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; -if(vr.instrument_soft){ - interflop_checkdenorm_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); -}else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + float res_temp; + interflop_checkdenorm_mul_float(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_float(res_temp, *arg3, &res, backend_checkdenorm_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37661,14 +37569,17 @@ if(vr.instrument_soft){ return *d; } // generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verroucheckcancellationmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verrou_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; +if(vr.instrument_soft){ interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37677,7 +37588,8 @@ static VG_REGPARM(3) Long vr_verroucheckcancellationmadd64F (Long a, Long b, Lon return *d; } -static VG_REGPARM(3) Long vr_conv_verroucheckcancellationmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37689,7 +37601,6 @@ static VG_REGPARM(3) Long vr_conv_verroucheckcancellationmadd64F (Long a, Long b double res; float resf; interflop_verrou_madd_float(arg1f, arg2f, arg3f, &resf, backend_verrou_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -37697,17 +37608,33 @@ static VG_REGPARM(3) Long vr_conv_verroucheckcancellationmadd64F (Long a, Long b #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verroucheckcancellationmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; +if(vr.instrument_soft){ interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37715,15 +37642,22 @@ static VG_REGPARM(3) Int vr_verroucheckcancellationmadd32F (Long a, Long b, Long Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verroucheckcancellationmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37732,7 +37666,8 @@ static VG_REGPARM(3) Long vr_verroucheckcancellationmsub64F (Long a, Long b, Lon return *d; } -static VG_REGPARM(3) Long vr_conv_verroucheckcancellationmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37743,8 +37678,9 @@ static VG_REGPARM(3) Long vr_conv_verroucheckcancellationmsub64F (Long a, Long b double res; float resf; - interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); + float res_temp; + interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -37752,34 +37688,13 @@ static VG_REGPARM(3) Long vr_conv_verroucheckcancellationmsub64F (Long a, Long b #endif Long *d = (Long*)(&res); return *d; -} - - -static VG_REGPARM(3) Int vr_verroucheckcancellationmsub32F (Long a, Long b, Long c) { -#ifdef USE_VERROU_FMA - float *arg1 = (float*)(&a); - float *arg2 = (float*)(&b); - float *arg3 = (float*)(&c); - float res; - interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); -#else - float res=0.; - VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); -#endif - Int *d = (Int*)(&res); - return *d; -} -#ifdef USE_VERROU_QUADMATH -// generation of operation madd backend mcaquad -static VG_REGPARM(3) Long vr_mcaquadcheckcancellationmadd64F (Long a, Long b, Long c) { +}else{ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_mcaquad_madd_double(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37787,38 +37702,21 @@ static VG_REGPARM(3) Long vr_mcaquadcheckcancellationmadd64F (Long a, Long b, Lo Long *d = (Long*)(&res); return *d; } - -static VG_REGPARM(3) Long vr_conv_mcaquadcheckcancellationmadd64F (Long a, Long b, Long c) { -#ifdef USE_VERROU_FMA - double *arg1 = (double*)(&a); - double *arg2 = (double*)(&b); - double *arg3 = (double*)(&c); - float arg1f=*arg1; - float arg2f=*arg2; - float arg3f=*arg3; - - double res; - float resf; - interflop_mcaquad_madd_float(arg1f, arg2f, arg3f, &resf, backend_mcaquad_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); - res=resf; -#else - double res=0.; - VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); -#endif - Long *d = (Long*)(&res); - return *d; } - -static VG_REGPARM(3) Int vr_mcaquadcheckcancellationmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_mcaquad_madd_float(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37826,15 +37724,18 @@ static VG_REGPARM(3) Int vr_mcaquadcheckcancellationmadd32F (Long a, Long b, Lon Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend mcaquad -static VG_REGPARM(3) Long vr_mcaquadcheckcancellationmsub64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_mcaquad_madd_double(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +if(vr.instrument_soft){ + interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37843,7 +37744,8 @@ static VG_REGPARM(3) Long vr_mcaquadcheckcancellationmsub64F (Long a, Long b, Lo return *d; } -static VG_REGPARM(3) Long vr_conv_mcaquadcheckcancellationmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37854,8 +37756,7 @@ static VG_REGPARM(3) Long vr_conv_mcaquadcheckcancellationmsub64F (Long a, Long double res; float resf; - interflop_mcaquad_madd_float(arg1f, arg2f, - arg3f, &resf, backend_mcaquad_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); + interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -37863,34 +37764,13 @@ static VG_REGPARM(3) Long vr_conv_mcaquadcheckcancellationmsub64F (Long a, Long #endif Long *d = (Long*)(&res); return *d; -} - - -static VG_REGPARM(3) Int vr_mcaquadcheckcancellationmsub32F (Long a, Long b, Long c) { -#ifdef USE_VERROU_FMA - float *arg1 = (float*)(&a); - float *arg2 = (float*)(&b); - float *arg3 = (float*)(&c); - float res; - interflop_mcaquad_madd_float(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); -#else - float res=0.; - VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); -#endif - Int *d = (Int*)(&res); - return *d; -} -#endif //USE_VERROU_QUADMATH -// generation of operation madd backend checkdenorm -static VG_REGPARM(3) Long vr_checkdenormcheckcancellationmadd64F (Long a, Long b, Long c) { +}else{ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_checkdenorm_madd_double(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37898,38 +37778,19 @@ static VG_REGPARM(3) Long vr_checkdenormcheckcancellationmadd64F (Long a, Long b Long *d = (Long*)(&res); return *d; } - -static VG_REGPARM(3) Long vr_conv_checkdenormcheckcancellationmadd64F (Long a, Long b, Long c) { -#ifdef USE_VERROU_FMA - double *arg1 = (double*)(&a); - double *arg2 = (double*)(&b); - double *arg3 = (double*)(&c); - float arg1f=*arg1; - float arg2f=*arg2; - float arg3f=*arg3; - - double res; - float resf; - interflop_checkdenorm_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkdenorm_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); - res=resf; -#else - double res=0.; - VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); -#endif - Long *d = (Long*)(&res); - return *d; } - -static VG_REGPARM(3) Int vr_checkdenormcheckcancellationmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_checkdenorm_madd_float(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +if(vr.instrument_soft){ + interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37937,15 +37798,22 @@ static VG_REGPARM(3) Int vr_checkdenormcheckcancellationmadd32F (Long a, Long b, Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend checkdenorm -static VG_REGPARM(3) Long vr_checkdenormcheckcancellationmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_checkdenorm_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37954,7 +37822,8 @@ static VG_REGPARM(3) Long vr_checkdenormcheckcancellationmsub64F (Long a, Long b return *d; } -static VG_REGPARM(3) Long vr_conv_checkdenormcheckcancellationmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -37965,8 +37834,9 @@ static VG_REGPARM(3) Long vr_conv_checkdenormcheckcancellationmsub64F (Long a, L double res; float resf; - interflop_checkdenorm_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkdenorm_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); + float res_temp; + interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -37974,17 +37844,35 @@ static VG_REGPARM(3) Long vr_conv_checkdenormcheckcancellationmsub64F (Long a, L #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_checkdenormcheckcancellationmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_checkdenorm_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -37992,16 +37880,16 @@ static VG_REGPARM(3) Int vr_checkdenormcheckcancellationmsub32F (Long a, Long b, Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verroucheckcancellation_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_QUADMATH +// generation of operation madd backend mcaquad +static VG_REGPARM(3) Long vr_mcaquad_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); + interflop_mcaquad_madd_double(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); }else{ interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); } @@ -38013,7 +37901,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verroucheckcancellation_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_mcaquad_softmadd64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -38025,8 +37913,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float(arg1f, arg2f, arg3f, &resf, backend_verrou_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); + interflop_mcaquad_madd_float(arg1f, arg2f, arg3f, &resf, backend_mcaquad_context); res=resf; #else double res=0.; @@ -38050,15 +37937,14 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verroucheckcancellation_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_mcaquad_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); + interflop_mcaquad_madd_float(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); }else{ interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); } @@ -38069,18 +37955,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verroucheckcancellation_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_mcaquad_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); + interflop_mcaquad_mul_double(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_double(res_temp, *arg3, &res, backend_mcaquad_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_mcaquad_madd_double(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); } #else double res=0.; @@ -38090,7 +37979,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verroucheckcancellation_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_mcaquad_softmadd64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -38102,8 +37991,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); + float res_temp; + interflop_mcaquad_mul_float(arg1f, arg2f, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_float(res_temp, arg3f, &resf, backend_mcaquad_context); res=resf; #else double res=0.; @@ -38117,7 +38007,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38127,17 +38017,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verroucheckcancellation_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_mcaquad_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); + interflop_mcaquad_mul_float(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_float(res_temp, *arg3, &res, backend_mcaquad_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_mcaquad_madd_float(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); } #else float res=0.; @@ -38146,19 +38037,17 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -#ifdef USE_VERROU_QUADMATH -// generation of operation madd backend mcaquad -static VG_REGPARM(3) Long vr_mcaquadcheckcancellation_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend mcaquad +static VG_REGPARM(3) Long vr_mcaquad_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_mcaquad_madd_double(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); + interflop_mcaquad_madd_double(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else double res=0.; @@ -38168,7 +38057,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_mcaquadcheckcancellation_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_mcaquad_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -38180,8 +38069,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_mcaquad_madd_float(arg1f, arg2f, arg3f, &resf, backend_mcaquad_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); + interflop_mcaquad_madd_float(arg1f, arg2f, - arg3f, &resf, backend_mcaquad_context); res=resf; #else double res=0.; @@ -38195,7 +38083,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38205,17 +38093,16 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_mcaquadcheckcancellation_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_mcaquad_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_mcaquad_madd_float(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); + interflop_mcaquad_madd_float(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else float res=0.; @@ -38224,18 +38111,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend mcaquad -static VG_REGPARM(3) Long vr_mcaquadcheckcancellation_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_mcaquad_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_mcaquad_madd_double(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); + interflop_mcaquad_mul_double(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_double(res_temp, *arg3, &res, backend_mcaquad_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_mcaquad_madd_double(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); } #else double res=0.; @@ -38245,7 +38135,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_mcaquadcheckcancellation_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_mcaquad_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -38257,8 +38147,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_mcaquad_madd_float(arg1f, arg2f, - arg3f, &resf, backend_mcaquad_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); + float res_temp; + interflop_mcaquad_mul_float(arg1f, arg2f, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_float(res_temp, arg3f, &resf, backend_mcaquad_context); res=resf; #else double res=0.; @@ -38272,7 +38163,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38282,17 +38173,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_mcaquadcheckcancellation_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_mcaquad_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_mcaquad_madd_float(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); + interflop_mcaquad_mul_float(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_float(res_temp, *arg3, &res, backend_mcaquad_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_mcaquad_madd_float(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); } #else float res=0.; @@ -38303,7 +38195,7 @@ if(vr.instrument_soft){ } #endif //USE_VERROU_QUADMATH // generation of operation madd backend checkdenorm -static VG_REGPARM(3) Long vr_checkdenormcheckcancellation_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_checkdenorm_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -38311,7 +38203,6 @@ static VG_REGPARM(3) Long vr_checkdenormcheckcancellation_softmadd64F (Long a, L double res; if(vr.instrument_soft){ interflop_checkdenorm_madd_double(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); }else{ interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); } @@ -38323,7 +38214,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_checkdenormcheckcancellation_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_checkdenorm_softmadd64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -38336,7 +38227,6 @@ if(vr.instrument_soft){ double res; float resf; interflop_checkdenorm_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkdenorm_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -38360,7 +38250,7 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_checkdenormcheckcancellation_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_checkdenorm_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); @@ -38368,7 +38258,6 @@ static VG_REGPARM(3) Int vr_checkdenormcheckcancellation_softmadd32F (Long a, Lo float res; if(vr.instrument_soft){ interflop_checkdenorm_madd_float(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); }else{ interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); } @@ -38379,18 +38268,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend checkdenorm -static VG_REGPARM(3) Long vr_checkdenormcheckcancellation_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_checkdenorm_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_checkdenorm_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); - interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); + interflop_checkdenorm_mul_double(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_double(res_temp, *arg3, &res, backend_checkdenorm_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_checkdenorm_madd_double(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); } #else double res=0.; @@ -38400,7 +38292,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_checkdenormcheckcancellation_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_checkdenorm_softmadd64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -38412,8 +38304,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_checkdenorm_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkdenorm_context); - interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); + float res_temp; + interflop_checkdenorm_mul_float(arg1f, arg2f, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_float(res_temp, arg3f, &resf, backend_checkdenorm_context); res=resf; #else double res=0.; @@ -38427,7 +38320,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38437,17 +38330,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_checkdenormcheckcancellation_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_checkdenorm_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_checkdenorm_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); - interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); + interflop_checkdenorm_mul_float(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_float(res_temp, *arg3, &res, backend_checkdenorm_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_checkdenorm_madd_float(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); } #else float res=0.; @@ -38456,15 +38350,18 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verroucheck_float_maxmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend checkdenorm +static VG_REGPARM(3) Long vr_checkdenorm_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); - interflop_check_float_max_madd_double(*arg1, *arg2, *arg3, &res, backend_check_float_max_context); +if(vr.instrument_soft){ + interflop_checkdenorm_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38473,53 +38370,33 @@ static VG_REGPARM(3) Long vr_verroucheck_float_maxmadd64F (Long a, Long b, Long return *d; } -/*static VG_REGPARM(3) Long vr_conv_verroucheck_float_maxmadd64F (Long a, Long b, Long c) {*/ -/*#ifdef USE_VERROU_FMA*/ -/* double *arg1 = (double*)(&a);*/ -/* double *arg2 = (double*)(&b);*/ -/* double *arg3 = (double*)(&c);*/ -/* float arg1f=*arg1;*/ -/* float arg2f=*arg2;*/ -/* float arg3f=*arg3;*/ - -/* double res;*/ -/* float resf;*/ -/* interflop_verrou_madd_float(arg1f, arg2f, arg3f, &resf, backend_verrou_context);*/ -/* interflop_check_float_max_madd_float(arg1f, arg2f, arg3f, &resf, backend_check_float_max_context);*/ -/* res=resf;*/ -/*#else*/ -/* double res=0.;*/ -/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ -/*#endif*/ -/* Long *d = (Long*)(&res);*/ -/* return *d;*/ -/*}*/ - - -static VG_REGPARM(3) Int vr_verroucheck_float_maxmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_checkdenorm_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA - float *arg1 = (float*)(&a); - float *arg2 = (float*)(&b); - float *arg3 = (float*)(&c); - float res; - interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); - interflop_check_float_max_madd_float(*arg1, *arg2, *arg3, &res, backend_check_float_max_context); + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_checkdenorm_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkdenorm_context); + res=resf; #else - float res=0.; + double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); #endif - Int *d = (Int*)(&res); + Long *d = (Long*)(&res); return *d; -} -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verroucheck_float_maxmsub64F (Long a, Long b, Long c) { +}else{ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); - interflop_check_float_max_madd_double(*arg1, *arg2, - *arg3, &res, backend_check_float_max_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38527,38 +38404,19 @@ static VG_REGPARM(3) Long vr_verroucheck_float_maxmsub64F (Long a, Long b, Long Long *d = (Long*)(&res); return *d; } +} -/*static VG_REGPARM(3) Long vr_conv_verroucheck_float_maxmsub64F (Long a, Long b, Long c) {*/ -/*#ifdef USE_VERROU_FMA*/ -/* double *arg1 = (double*)(&a);*/ -/* double *arg2 = (double*)(&b);*/ -/* double *arg3 = (double*)(&c);*/ -/* float arg1f=*arg1;*/ -/* float arg2f=*arg2;*/ -/* float arg3f=*arg3;*/ - -/* double res;*/ -/* float resf;*/ -/* interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context);*/ -/* interflop_check_float_max_madd_float(arg1f, arg2f, - arg3f, &resf, backend_check_float_max_context);*/ -/* res=resf;*/ -/*#else*/ -/* double res=0.;*/ -/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ -/*#endif*/ -/* Long *d = (Long*)(&res);*/ -/* return *d;*/ -/*}*/ - - -static VG_REGPARM(3) Int vr_verroucheck_float_maxmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_checkdenorm_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); - interflop_check_float_max_madd_float(*arg1, *arg2, - *arg3, &res, backend_check_float_max_context); +if(vr.instrument_soft){ + interflop_checkdenorm_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38566,18 +38424,21 @@ static VG_REGPARM(3) Int vr_verroucheck_float_maxmsub32F (Long a, Long b, Long c Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verroucheck_float_max_softmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_checkdenorm_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); - interflop_check_float_max_madd_double(*arg1, *arg2, *arg3, &res, backend_check_float_max_context); + interflop_checkdenorm_mul_double(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_double(res_temp, *arg3, &res, backend_checkdenorm_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_checkdenorm_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); } #else double res=0.; @@ -38587,54 +38448,56 @@ if(vr.instrument_soft){ return *d; } -/*static VG_REGPARM(3) Long vr_conv_verroucheck_float_max_softmadd64F (Long a, Long b, Long c) {*/ -/*if(vr.instrument_soft){*/ -/*#ifdef USE_VERROU_FMA*/ -/* double *arg1 = (double*)(&a);*/ -/* double *arg2 = (double*)(&b);*/ -/* double *arg3 = (double*)(&c);*/ -/* float arg1f=*arg1;*/ -/* float arg2f=*arg2;*/ -/* float arg3f=*arg3;*/ +static VG_REGPARM(3) Long vr_unfused_conv_checkdenorm_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; -/* double res;*/ -/* float resf;*/ -/* interflop_verrou_madd_float(arg1f, arg2f, arg3f, &resf, backend_verrou_context);*/ -/* interflop_check_float_max_madd_float(arg1f, arg2f, arg3f, &resf, backend_check_float_max_context);*/ -/* res=resf;*/ -/*#else*/ -/* double res=0.;*/ -/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ -/*#endif*/ -/* Long *d = (Long*)(&res);*/ -/* return *d;*/ -/*}else{*/ -/*#ifdef USE_VERROU_FMA*/ -/* double *arg1 = (double*)(&a);*/ -/* double *arg2 = (double*)(&b);*/ -/* double *arg3 = (double*)(&c);*/ -/* double res;*/ -/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context);*/ -/*#else*/ -/* double res=0.;*/ -/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ -/*#endif*/ -/* Long *d = (Long*)(&res);*/ -/* return *d;*/ -/*} + double res; + float resf; + float res_temp; + interflop_checkdenorm_mul_float(arg1f, arg2f, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_float(res_temp, arg3f, &resf, backend_checkdenorm_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; } -*/ -static VG_REGPARM(3) Int vr_verroucheck_float_max_softmadd32F (Long a, Long b, Long c) { +} + +static VG_REGPARM(3) Int vr_unfused_checkdenorm_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); - interflop_check_float_max_madd_float(*arg1, *arg2, *arg3, &res, backend_check_float_max_context); + interflop_checkdenorm_mul_float(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_float(res_temp, *arg3, &res, backend_checkdenorm_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_checkdenorm_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); } #else float res=0.; @@ -38643,19 +38506,15 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verroucheck_float_max_softmsub64F (Long a, Long b, Long c) { +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verroucheckcancellationmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; -if(vr.instrument_soft){ - interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); - interflop_check_float_max_madd_double(*arg1, *arg2, - *arg3, &res, backend_check_float_max_context); -}else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38664,55 +38523,37 @@ if(vr.instrument_soft){ return *d; } -/*static VG_REGPARM(3) Long vr_conv_verroucheck_float_max_softmsub64F (Long a, Long b, Long c) {*/ -/*if(vr.instrument_soft){*/ -/*#ifdef USE_VERROU_FMA*/ -/* double *arg1 = (double*)(&a);*/ -/* double *arg2 = (double*)(&b);*/ -/* double *arg3 = (double*)(&c);*/ -/* float arg1f=*arg1;*/ -/* float arg2f=*arg2;*/ -/* float arg3f=*arg3;*/ +static VG_REGPARM(3) Long vr_conv_verroucheckcancellationmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; -/* double res;*/ -/* float resf;*/ -/* interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context);*/ -/* interflop_check_float_max_madd_float(arg1f, arg2f, - arg3f, &resf, backend_check_float_max_context);*/ -/* res=resf;*/ -/*#else*/ -/* double res=0.;*/ -/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ -/*#endif*/ -/* Long *d = (Long*)(&res);*/ -/* return *d;*/ -/*}else{*/ -/*#ifdef USE_VERROU_FMA*/ -/* double *arg1 = (double*)(&a);*/ -/* double *arg2 = (double*)(&b);*/ -/* double *arg3 = (double*)(&c);*/ -/* double res;*/ -/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context);*/ -/*#else*/ -/* double res=0.;*/ -/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ -/*#endif*/ -/* Long *d = (Long*)(&res);*/ -/* return *d;*/ -/*} + double res; + float resf; + interflop_verrou_madd_float(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; } -*/ -static VG_REGPARM(3) Int vr_verroucheck_float_max_softmsub32F (Long a, Long b, Long c) { + + +static VG_REGPARM(3) Int vr_verroucheckcancellationmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; -if(vr.instrument_soft){ - interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); - interflop_check_float_max_madd_float(*arg1, *arg2, - *arg3, &res, backend_check_float_max_context); -}else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38720,14 +38561,19 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_NEARESTmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verroucheckcancellationmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_context); + double res_temp; + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double(res_temp, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_add_double(res_temp, *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38736,7 +38582,7 @@ static VG_REGPARM(3) Long vr_verrou_NEARESTmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_NEARESTmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verroucheckcancellationmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -38747,7 +38593,10 @@ static VG_REGPARM(3) Long vr_conv_verrou_NEARESTmadd64F (Long a, Long b, Long c) double res; float resf; - interflop_verrou_madd_float_NEAREST(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float(res_temp, arg3f, &resf, backend_verrou_context); + interflop_checkcancellation_add_float(res_temp, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -38757,14 +38606,16 @@ static VG_REGPARM(3) Long vr_conv_verrou_NEARESTmadd64F (Long a, Long b, Long c) return *d; } - -static VG_REGPARM(3) Int vr_verrou_NEARESTmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verroucheckcancellationmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float(res_temp, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_add_float(res_temp, *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38772,14 +38623,15 @@ static VG_REGPARM(3) Int vr_verrou_NEARESTmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_UPWARDmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verroucheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_UPWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38788,7 +38640,7 @@ static VG_REGPARM(3) Long vr_verrou_UPWARDmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_UPWARDmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verroucheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -38799,7 +38651,8 @@ static VG_REGPARM(3) Long vr_conv_verrou_UPWARDmadd64F (Long a, Long b, Long c) double res; float resf; - interflop_verrou_madd_float_UPWARD(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -38810,13 +38663,14 @@ static VG_REGPARM(3) Long vr_conv_verrou_UPWARDmadd64F (Long a, Long b, Long c) } -static VG_REGPARM(3) Int vr_verrou_UPWARDmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verroucheckcancellationmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_UPWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38824,14 +38678,19 @@ static VG_REGPARM(3) Int vr_verrou_UPWARDmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_DOWNWARDmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verroucheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_DOWNWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); + double res_temp; + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double(res_temp, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_sub_double(res_temp, *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38840,7 +38699,7 @@ static VG_REGPARM(3) Long vr_verrou_DOWNWARDmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARDmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verroucheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -38851,7 +38710,10 @@ static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARDmadd64F (Long a, Long b, Long c double res; float resf; - interflop_verrou_madd_float_DOWNWARD(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float(res_temp, arg3f, &resf, backend_verrou_context); + interflop_checkcancellation_sub_float(res_temp, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -38861,14 +38723,16 @@ static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARDmadd64F (Long a, Long b, Long c return *d; } - -static VG_REGPARM(3) Int vr_verrou_DOWNWARDmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verroucheckcancellationmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_DOWNWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float(res_temp, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_sub_float(res_temp, *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38876,14 +38740,16 @@ static VG_REGPARM(3) Int vr_verrou_DOWNWARDmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_FARTHESTmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_QUADMATH +// generation of operation madd backend mcaquad +static VG_REGPARM(3) Long vr_mcaquadcheckcancellationmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_FARTHEST(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_mcaquad_madd_double(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38892,7 +38758,7 @@ static VG_REGPARM(3) Long vr_verrou_FARTHESTmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_FARTHESTmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_mcaquadcheckcancellationmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -38903,7 +38769,8 @@ static VG_REGPARM(3) Long vr_conv_verrou_FARTHESTmadd64F (Long a, Long b, Long c double res; float resf; - interflop_verrou_madd_float_FARTHEST(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_mcaquad_madd_float(arg1f, arg2f, arg3f, &resf, backend_mcaquad_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -38914,13 +38781,14 @@ static VG_REGPARM(3) Long vr_conv_verrou_FARTHESTmadd64F (Long a, Long b, Long c } -static VG_REGPARM(3) Int vr_verrou_FARTHESTmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_mcaquadcheckcancellationmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_FARTHEST(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_mcaquad_madd_float(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38928,14 +38796,19 @@ static VG_REGPARM(3) Int vr_verrou_FARTHESTmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_ZEROmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_mcaquadcheckcancellationmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); + double res_temp; + interflop_mcaquad_mul_double(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_double(res_temp, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_add_double(res_temp, *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38944,7 +38817,7 @@ static VG_REGPARM(3) Long vr_verrou_ZEROmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_ZEROmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_mcaquadcheckcancellationmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -38955,7 +38828,10 @@ static VG_REGPARM(3) Long vr_conv_verrou_ZEROmadd64F (Long a, Long b, Long c) { double res; float resf; - interflop_verrou_madd_float_ZERO(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_mcaquad_mul_float(arg1f, arg2f, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_float(res_temp, arg3f, &resf, backend_mcaquad_context); + interflop_checkcancellation_add_float(res_temp, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -38965,14 +38841,16 @@ static VG_REGPARM(3) Long vr_conv_verrou_ZEROmadd64F (Long a, Long b, Long c) { return *d; } - -static VG_REGPARM(3) Int vr_verrou_ZEROmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_mcaquadcheckcancellationmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); + float res_temp; + interflop_mcaquad_mul_float(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_float(res_temp, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_add_float(res_temp, *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38980,14 +38858,15 @@ static VG_REGPARM(3) Int vr_verrou_ZEROmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_AWAY_ZEROmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend mcaquad +static VG_REGPARM(3) Long vr_mcaquadcheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_AWAY_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_mcaquad_madd_double(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -38996,7 +38875,7 @@ static VG_REGPARM(3) Long vr_verrou_AWAY_ZEROmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZEROmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_mcaquadcheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39007,7 +38886,8 @@ static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZEROmadd64F (Long a, Long b, Long double res; float resf; - interflop_verrou_madd_float_AWAY_ZERO(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_mcaquad_madd_float(arg1f, arg2f, - arg3f, &resf, backend_mcaquad_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39018,13 +38898,14 @@ static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZEROmadd64F (Long a, Long b, Long } -static VG_REGPARM(3) Int vr_verrou_AWAY_ZEROmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_mcaquadcheckcancellationmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_AWAY_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_mcaquad_madd_float(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39032,14 +38913,19 @@ static VG_REGPARM(3) Int vr_verrou_AWAY_ZEROmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOMmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_mcaquadcheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_RANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); + double res_temp; + interflop_mcaquad_mul_double(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_double(res_temp, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_sub_double(res_temp, *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39048,7 +38934,7 @@ static VG_REGPARM(3) Long vr_verrou_RANDOMmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOMmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_mcaquadcheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39059,7 +38945,10 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOMmadd64F (Long a, Long b, Long c) double res; float resf; - interflop_verrou_madd_float_RANDOM(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_mcaquad_mul_float(arg1f, arg2f, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_float(res_temp, arg3f, &resf, backend_mcaquad_context); + interflop_checkcancellation_sub_float(res_temp, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39069,14 +38958,16 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOMmadd64F (Long a, Long b, Long c) return *d; } - -static VG_REGPARM(3) Int vr_verrou_RANDOMmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_mcaquadcheckcancellationmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_RANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); + float res_temp; + interflop_mcaquad_mul_float(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_float(res_temp, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_sub_float(res_temp, *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39084,14 +38975,16 @@ static VG_REGPARM(3) Int vr_verrou_RANDOMmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_DETmadd64F (Long a, Long b, Long c) { +#endif //USE_VERROU_QUADMATH +// generation of operation madd backend checkdenorm +static VG_REGPARM(3) Long vr_checkdenormcheckcancellationmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_RANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_checkdenorm_madd_double(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39100,7 +38993,7 @@ static VG_REGPARM(3) Long vr_verrou_RANDOM_DETmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DETmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_checkdenormcheckcancellationmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39111,7 +39004,8 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DETmadd64F (Long a, Long b, Long double res; float resf; - interflop_verrou_madd_float_RANDOM_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_checkdenorm_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkdenorm_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39122,13 +39016,14 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DETmadd64F (Long a, Long b, Long } -static VG_REGPARM(3) Int vr_verrou_RANDOM_DETmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_checkdenormcheckcancellationmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_RANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_checkdenorm_madd_float(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39136,14 +39031,19 @@ static VG_REGPARM(3) Int vr_verrou_RANDOM_DETmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_COMDETmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_checkdenormcheckcancellationmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_RANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + double res_temp; + interflop_checkdenorm_mul_double(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_double(res_temp, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_add_double(res_temp, *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39152,7 +39052,7 @@ static VG_REGPARM(3) Long vr_verrou_RANDOM_COMDETmadd64F (Long a, Long b, Long c return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDETmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_checkdenormcheckcancellationmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39163,7 +39063,10 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDETmadd64F (Long a, Long b, L double res; float resf; - interflop_verrou_madd_float_RANDOM_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_checkdenorm_mul_float(arg1f, arg2f, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_float(res_temp, arg3f, &resf, backend_checkdenorm_context); + interflop_checkcancellation_add_float(res_temp, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39173,14 +39076,16 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDETmadd64F (Long a, Long b, L return *d; } - -static VG_REGPARM(3) Int vr_verrou_RANDOM_COMDETmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_checkdenormcheckcancellationmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_RANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + float res_temp; + interflop_checkdenorm_mul_float(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_float(res_temp, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_add_float(res_temp, *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39188,14 +39093,15 @@ static VG_REGPARM(3) Int vr_verrou_RANDOM_COMDETmadd32F (Long a, Long b, Long c) Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGEmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend checkdenorm +static VG_REGPARM(3) Long vr_checkdenormcheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_AVERAGE(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_checkdenorm_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39204,7 +39110,7 @@ static VG_REGPARM(3) Long vr_verrou_AVERAGEmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGEmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_checkdenormcheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39215,7 +39121,8 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGEmadd64F (Long a, Long b, Long c) double res; float resf; - interflop_verrou_madd_float_AVERAGE(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_checkdenorm_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkdenorm_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39226,13 +39133,14 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGEmadd64F (Long a, Long b, Long c) } -static VG_REGPARM(3) Int vr_verrou_AVERAGEmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_checkdenormcheckcancellationmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_AVERAGE(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_checkdenorm_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39240,14 +39148,19 @@ static VG_REGPARM(3) Int vr_verrou_AVERAGEmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_DETmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_checkdenormcheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_AVERAGE_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + double res_temp; + interflop_checkdenorm_mul_double(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_double(res_temp, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_sub_double(res_temp, *arg3, &res, backend_checkcancellation_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39256,7 +39169,7 @@ static VG_REGPARM(3) Long vr_verrou_AVERAGE_DETmadd64F (Long a, Long b, Long c) return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DETmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_checkdenormcheckcancellationmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39267,7 +39180,10 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DETmadd64F (Long a, Long b, Lon double res; float resf; - interflop_verrou_madd_float_AVERAGE_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_checkdenorm_mul_float(arg1f, arg2f, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_float(res_temp, arg3f, &resf, backend_checkdenorm_context); + interflop_checkcancellation_sub_float(res_temp, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39277,14 +39193,16 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DETmadd64F (Long a, Long b, Lon return *d; } - -static VG_REGPARM(3) Int vr_verrou_AVERAGE_DETmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_checkdenormcheckcancellationmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_AVERAGE_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + float res_temp; + interflop_checkdenorm_mul_float(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_float(res_temp, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_sub_float(res_temp, *arg3, &res, backend_checkcancellation_context); #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39293,13 +39211,18 @@ static VG_REGPARM(3) Int vr_verrou_AVERAGE_DETmadd32F (Long a, Long b, Long c) { return *d; } // generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_COMDETmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verroucheckcancellation_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_AVERAGE_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39308,7 +39231,8 @@ static VG_REGPARM(3) Long vr_verrou_AVERAGE_COMDETmadd64F (Long a, Long b, Long return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDETmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verroucheckcancellation_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39319,7 +39243,8 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDETmadd64F (Long a, Long b, double res; float resf; - interflop_verrou_madd_float_AVERAGE_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39327,16 +39252,34 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDETmadd64F (Long a, Long b, #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_AVERAGE_COMDETmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verroucheckcancellation_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_AVERAGE_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39344,14 +39287,24 @@ static VG_REGPARM(3) Int vr_verrou_AVERAGE_COMDETmadd32F (Long a, Long b, Long c Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOMmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verroucheckcancellation_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_PRANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double(res_temp, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_add_double(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39360,7 +39313,8 @@ static VG_REGPARM(3) Long vr_verrou_PRANDOMmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOMmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verroucheckcancellation_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39371,7 +39325,10 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOMmadd64F (Long a, Long b, Long c) double res; float resf; - interflop_verrou_madd_float_PRANDOM(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float(res_temp, arg3f, &resf, backend_verrou_context); + interflop_checkcancellation_add_float(res_temp, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39379,16 +39336,37 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOMmadd64F (Long a, Long b, Long c) #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_PRANDOMmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verroucheckcancellation_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_PRANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float(res_temp, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_add_float(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39396,14 +39374,19 @@ static VG_REGPARM(3) Int vr_verrou_PRANDOMmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOM_DETmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verroucheckcancellation_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_PRANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39412,7 +39395,8 @@ static VG_REGPARM(3) Long vr_verrou_PRANDOM_DETmadd64F (Long a, Long b, Long c) return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DETmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verroucheckcancellation_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39423,7 +39407,8 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DETmadd64F (Long a, Long b, Lon double res; float resf; - interflop_verrou_madd_float_PRANDOM_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39431,16 +39416,34 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DETmadd64F (Long a, Long b, Lon #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_PRANDOM_DETmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verroucheckcancellation_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_PRANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39448,14 +39451,24 @@ static VG_REGPARM(3) Int vr_verrou_PRANDOM_DETmadd32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOM_COMDETmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verroucheckcancellation_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_PRANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double(res_temp, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_sub_double(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39464,7 +39477,8 @@ static VG_REGPARM(3) Long vr_verrou_PRANDOM_COMDETmadd64F (Long a, Long b, Long return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDETmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verroucheckcancellation_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39475,7 +39489,10 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDETmadd64F (Long a, Long b, double res; float resf; - interflop_verrou_madd_float_PRANDOM_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float(res_temp, arg3f, &resf, backend_verrou_context); + interflop_checkcancellation_sub_float(res_temp, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39483,16 +39500,37 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDETmadd64F (Long a, Long b, #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_PRANDOM_COMDETmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verroucheckcancellation_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_PRANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float(res_temp, *arg3, &res, backend_verrou_context); + interflop_checkcancellation_sub_float(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39500,14 +39538,20 @@ static VG_REGPARM(3) Int vr_verrou_PRANDOM_COMDETmadd32F (Long a, Long b, Long c Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_SCOMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_QUADMATH +// generation of operation madd backend mcaquad +static VG_REGPARM(3) Long vr_mcaquadcheckcancellation_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_RANDOM_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_mcaquad_madd_double(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39516,7 +39560,8 @@ static VG_REGPARM(3) Long vr_verrou_RANDOM_SCOMDETmadd64F (Long a, Long b, Long return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDETmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_mcaquadcheckcancellation_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39527,7 +39572,8 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDETmadd64F (Long a, Long b, double res; float resf; - interflop_verrou_madd_float_RANDOM_SCOMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_mcaquad_madd_float(arg1f, arg2f, arg3f, &resf, backend_mcaquad_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39535,16 +39581,34 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDETmadd64F (Long a, Long b, #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_RANDOM_SCOMDETmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_mcaquadcheckcancellation_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_RANDOM_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_mcaquad_madd_float(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39552,14 +39616,24 @@ static VG_REGPARM(3) Int vr_verrou_RANDOM_SCOMDETmadd32F (Long a, Long b, Long c Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_SCOMDETmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_mcaquadcheckcancellation_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_AVERAGE_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_mcaquad_mul_double(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_double(res_temp, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_add_double(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_mcaquad_madd_double(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39568,7 +39642,8 @@ static VG_REGPARM(3) Long vr_verrou_AVERAGE_SCOMDETmadd64F (Long a, Long b, Long return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDETmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_mcaquadcheckcancellation_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39579,7 +39654,10 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDETmadd64F (Long a, Long b, double res; float resf; - interflop_verrou_madd_float_AVERAGE_SCOMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_mcaquad_mul_float(arg1f, arg2f, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_float(res_temp, arg3f, &resf, backend_mcaquad_context); + interflop_checkcancellation_add_float(res_temp, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39587,16 +39665,37 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDETmadd64F (Long a, Long b, #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_AVERAGE_SCOMDETmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_mcaquadcheckcancellation_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_AVERAGE_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_mcaquad_mul_float(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_add_float(res_temp, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_add_float(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_mcaquad_madd_float(*arg1, *arg2, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39604,14 +39703,19 @@ static VG_REGPARM(3) Int vr_verrou_AVERAGE_SCOMDETmadd32F (Long a, Long b, Long Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_SR_MONOTONICmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend mcaquad +static VG_REGPARM(3) Long vr_mcaquadcheckcancellation_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_SR_MONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_mcaquad_madd_double(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39620,7 +39724,8 @@ static VG_REGPARM(3) Long vr_verrou_SR_MONOTONICmadd64F (Long a, Long b, Long c) return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_SR_MONOTONICmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_mcaquadcheckcancellation_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39631,7 +39736,8 @@ static VG_REGPARM(3) Long vr_conv_verrou_SR_MONOTONICmadd64F (Long a, Long b, Lo double res; float resf; - interflop_verrou_madd_float_SR_MONOTONIC(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_mcaquad_madd_float(arg1f, arg2f, - arg3f, &resf, backend_mcaquad_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39639,16 +39745,34 @@ static VG_REGPARM(3) Long vr_conv_verrou_SR_MONOTONICmadd64F (Long a, Long b, Lo #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_SR_MONOTONICmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_mcaquadcheckcancellation_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_SR_MONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_mcaquad_madd_float(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39656,14 +39780,24 @@ static VG_REGPARM(3) Int vr_verrou_SR_MONOTONICmadd32F (Long a, Long b, Long c) Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_SR_SMONOTONICmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_mcaquadcheckcancellation_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_SR_SMONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_mcaquad_mul_double(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_double(res_temp, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_sub_double(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_mcaquad_madd_double(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39672,7 +39806,8 @@ static VG_REGPARM(3) Long vr_verrou_SR_SMONOTONICmadd64F (Long a, Long b, Long c return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONICmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_mcaquadcheckcancellation_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39683,7 +39818,10 @@ static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONICmadd64F (Long a, Long b, L double res; float resf; - interflop_verrou_madd_float_SR_SMONOTONIC(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_mcaquad_mul_float(arg1f, arg2f, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_float(res_temp, arg3f, &resf, backend_mcaquad_context); + interflop_checkcancellation_sub_float(res_temp, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39691,16 +39829,37 @@ static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONICmadd64F (Long a, Long b, L #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_SR_SMONOTONICmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_mcaquadcheckcancellation_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_SR_SMONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_mcaquad_mul_float(*arg1, *arg2, &res_temp, backend_mcaquad_context); + interflop_mcaquad_sub_float(res_temp, *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_sub_float(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_mcaquad_madd_float(*arg1, *arg2, - *arg3, &res, backend_mcaquad_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39708,14 +39867,20 @@ static VG_REGPARM(3) Int vr_verrou_SR_SMONOTONICmadd32F (Long a, Long b, Long c) Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_NEARESTmsub64F (Long a, Long b, Long c) { +#endif //USE_VERROU_QUADMATH +// generation of operation madd backend checkdenorm +static VG_REGPARM(3) Long vr_checkdenormcheckcancellation_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_checkdenorm_madd_double(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39724,7 +39889,8 @@ static VG_REGPARM(3) Long vr_verrou_NEARESTmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_NEARESTmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_checkdenormcheckcancellation_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39735,7 +39901,8 @@ static VG_REGPARM(3) Long vr_conv_verrou_NEARESTmsub64F (Long a, Long b, Long c) double res; float resf; - interflop_verrou_madd_float_NEAREST(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_checkdenorm_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkdenorm_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, arg3f, &resf, backend_checkcancellation_context); res=resf; #else double res=0.; @@ -39743,16 +39910,6711 @@ static VG_REGPARM(3) Long vr_conv_verrou_NEARESTmsub64F (Long a, Long b, Long c) #endif Long *d = (Long*)(&res); return *d; -} - - -static VG_REGPARM(3) Int vr_verrou_NEARESTmsub32F (Long a, Long b, Long c) { +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_checkdenormcheckcancellation_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_checkdenorm_madd_float(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_checkdenormcheckcancellation_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_checkdenorm_mul_double(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_double(res_temp, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_add_double(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_checkdenorm_madd_double(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_checkdenormcheckcancellation_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_checkdenorm_mul_float(arg1f, arg2f, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_float(res_temp, arg3f, &resf, backend_checkdenorm_context); + interflop_checkcancellation_add_float(res_temp, arg3f, &resf, backend_checkcancellation_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_checkdenormcheckcancellation_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_checkdenorm_mul_float(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_add_float(res_temp, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_add_float(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_checkdenorm_madd_float(*arg1, *arg2, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, *arg3, &res, backend_checkcancellation_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend checkdenorm +static VG_REGPARM(3) Long vr_checkdenormcheckcancellation_softmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_checkdenorm_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_checkdenormcheckcancellation_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_checkdenorm_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkdenorm_context); + interflop_checkcancellation_madd_float(arg1f, arg2f, - arg3f, &resf, backend_checkcancellation_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_checkdenormcheckcancellation_softmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_checkdenorm_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_checkdenormcheckcancellation_softmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_checkdenorm_mul_double(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_double(res_temp, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_sub_double(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_checkdenorm_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_double(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_checkdenormcheckcancellation_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_checkdenorm_mul_float(arg1f, arg2f, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_float(res_temp, arg3f, &resf, backend_checkdenorm_context); + interflop_checkcancellation_sub_float(res_temp, arg3f, &resf, backend_checkcancellation_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_checkdenormcheckcancellation_softmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_checkdenorm_mul_float(*arg1, *arg2, &res_temp, backend_checkdenorm_context); + interflop_checkdenorm_sub_float(res_temp, *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_sub_float(res_temp, *arg3, &res, backend_checkcancellation_context); +}else{ + interflop_checkdenorm_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkdenorm_context); + interflop_checkcancellation_madd_float(*arg1, *arg2, - *arg3, &res, backend_checkcancellation_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verroucheck_float_maxmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_double(*arg1, *arg2, *arg3, &res, backend_check_float_max_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +/*static VG_REGPARM(3) Long vr_conv_verroucheck_float_maxmadd64F (Long a, Long b, Long c) {*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* float arg1f=*arg1;*/ +/* float arg2f=*arg2;*/ +/* float arg3f=*arg3;*/ + +/* double res;*/ +/* float resf;*/ +/* interflop_verrou_madd_float(arg1f, arg2f, arg3f, &resf, backend_verrou_context);*/ +/* interflop_check_float_max_madd_float(arg1f, arg2f, arg3f, &resf, backend_check_float_max_context);*/ +/* res=resf;*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*}*/ + + +static VG_REGPARM(3) Int vr_verroucheck_float_maxmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_float(*arg1, *arg2, *arg3, &res, backend_check_float_max_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verroucheck_float_maxmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_check_float_max_mul_double(*arg1, *arg2, &res_temp, backend_check_float_max_context); + interflop_verrou_add_double(res_temp, *arg3, &res, backend_verrou_context); + interflop_check_float_max_add_double(res_temp, *arg3, &res, backend_check_float_max_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +/*static VG_REGPARM(3) Long vr_unfused_conv_verroucheck_float_maxmadd64F (Long a, Long b, Long c) {*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* float arg1f=*arg1;*/ +/* float arg2f=*arg2;*/ +/* float arg3f=*arg3;*/ + +/* double res;*/ +/* float resf;*/ +/* float res_temp;*/ +/* interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context);*/ +/* interflop_check_float_max_mul_float(arg1f, arg2f, &res_temp, backend_check_float_max_context);*/ +/* interflop_verrou_add_float(res_temp, arg3f, &resf, backend_verrou_context);*/ +/* interflop_check_float_max_add_float(res_temp, arg3f, &resf, backend_check_float_max_context);*/ +/* res=resf;*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*}*/ + +static VG_REGPARM(3) Int vr_unfused_verroucheck_float_maxmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_check_float_max_mul_float(*arg1, *arg2, &res_temp, backend_check_float_max_context); + interflop_verrou_add_float(res_temp, *arg3, &res, backend_verrou_context); + interflop_check_float_max_add_float(res_temp, *arg3, &res, backend_check_float_max_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verroucheck_float_maxmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_double(*arg1, *arg2, - *arg3, &res, backend_check_float_max_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +/*static VG_REGPARM(3) Long vr_conv_verroucheck_float_maxmsub64F (Long a, Long b, Long c) {*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* float arg1f=*arg1;*/ +/* float arg2f=*arg2;*/ +/* float arg3f=*arg3;*/ + +/* double res;*/ +/* float resf;*/ +/* interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context);*/ +/* interflop_check_float_max_madd_float(arg1f, arg2f, - arg3f, &resf, backend_check_float_max_context);*/ +/* res=resf;*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*}*/ + + +static VG_REGPARM(3) Int vr_verroucheck_float_maxmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_float(*arg1, *arg2, - *arg3, &res, backend_check_float_max_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verroucheck_float_maxmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_check_float_max_mul_double(*arg1, *arg2, &res_temp, backend_check_float_max_context); + interflop_verrou_sub_double(res_temp, *arg3, &res, backend_verrou_context); + interflop_check_float_max_sub_double(res_temp, *arg3, &res, backend_check_float_max_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +/*static VG_REGPARM(3) Long vr_unfused_conv_verroucheck_float_maxmsub64F (Long a, Long b, Long c) {*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* float arg1f=*arg1;*/ +/* float arg2f=*arg2;*/ +/* float arg3f=*arg3;*/ + +/* double res;*/ +/* float resf;*/ +/* float res_temp;*/ +/* interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context);*/ +/* interflop_check_float_max_mul_float(arg1f, arg2f, &res_temp, backend_check_float_max_context);*/ +/* interflop_verrou_sub_float(res_temp, arg3f, &resf, backend_verrou_context);*/ +/* interflop_check_float_max_sub_float(res_temp, arg3f, &resf, backend_check_float_max_context);*/ +/* res=resf;*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*}*/ + +static VG_REGPARM(3) Int vr_unfused_verroucheck_float_maxmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_check_float_max_mul_float(*arg1, *arg2, &res_temp, backend_check_float_max_context); + interflop_verrou_sub_float(res_temp, *arg3, &res, backend_verrou_context); + interflop_check_float_max_sub_float(res_temp, *arg3, &res, backend_check_float_max_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verroucheck_float_max_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_double(*arg1, *arg2, *arg3, &res, backend_check_float_max_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +/*static VG_REGPARM(3) Long vr_conv_verroucheck_float_max_softmadd64F (Long a, Long b, Long c) {*/ +/*if(vr.instrument_soft){*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* float arg1f=*arg1;*/ +/* float arg2f=*arg2;*/ +/* float arg3f=*arg3;*/ + +/* double res;*/ +/* float resf;*/ +/* interflop_verrou_madd_float(arg1f, arg2f, arg3f, &resf, backend_verrou_context);*/ +/* interflop_check_float_max_madd_float(arg1f, arg2f, arg3f, &resf, backend_check_float_max_context);*/ +/* res=resf;*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*}else{*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* double res;*/ +/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context);*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*} +} +*/ +static VG_REGPARM(3) Int vr_verroucheck_float_max_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_float(*arg1, *arg2, *arg3, &res, backend_check_float_max_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verroucheck_float_max_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_check_float_max_mul_double(*arg1, *arg2, &res_temp, backend_check_float_max_context); + interflop_verrou_add_double(res_temp, *arg3, &res, backend_verrou_context); + interflop_check_float_max_add_double(res_temp, *arg3, &res, backend_check_float_max_context); +}else{ + interflop_verrou_madd_double(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_double(*arg1, *arg2, *arg3, &res, backend_check_float_max_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +/*static VG_REGPARM(3) Long vr_unfused_conv_verroucheck_float_max_softmadd64F (Long a, Long b, Long c) {*/ +/*if(vr.instrument_soft){*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* float arg1f=*arg1;*/ +/* float arg2f=*arg2;*/ +/* float arg3f=*arg3;*/ + +/* double res;*/ +/* float resf;*/ +/* float res_temp;*/ +/* interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context);*/ +/* interflop_check_float_max_mul_float(arg1f, arg2f, &res_temp, backend_check_float_max_context);*/ +/* interflop_verrou_add_float(res_temp, arg3f, &resf, backend_verrou_context);*/ +/* interflop_check_float_max_add_float(res_temp, arg3f, &resf, backend_check_float_max_context);*/ +/* res=resf;*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*}else{*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* double res;*/ +/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context);*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*} +} +*/ +static VG_REGPARM(3) Int vr_unfused_verroucheck_float_max_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_check_float_max_mul_float(*arg1, *arg2, &res_temp, backend_check_float_max_context); + interflop_verrou_add_float(res_temp, *arg3, &res, backend_verrou_context); + interflop_check_float_max_add_float(res_temp, *arg3, &res, backend_check_float_max_context); +}else{ + interflop_verrou_madd_float(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_float(*arg1, *arg2, *arg3, &res, backend_check_float_max_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verroucheck_float_max_softmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_double(*arg1, *arg2, - *arg3, &res, backend_check_float_max_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +/*static VG_REGPARM(3) Long vr_conv_verroucheck_float_max_softmsub64F (Long a, Long b, Long c) {*/ +/*if(vr.instrument_soft){*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* float arg1f=*arg1;*/ +/* float arg2f=*arg2;*/ +/* float arg3f=*arg3;*/ + +/* double res;*/ +/* float resf;*/ +/* interflop_verrou_madd_float(arg1f, arg2f, - arg3f, &resf, backend_verrou_context);*/ +/* interflop_check_float_max_madd_float(arg1f, arg2f, - arg3f, &resf, backend_check_float_max_context);*/ +/* res=resf;*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*}else{*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* double res;*/ +/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context);*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*} +} +*/ +static VG_REGPARM(3) Int vr_verroucheck_float_max_softmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_float(*arg1, *arg2, - *arg3, &res, backend_check_float_max_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verroucheck_float_max_softmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_check_float_max_mul_double(*arg1, *arg2, &res_temp, backend_check_float_max_context); + interflop_verrou_sub_double(res_temp, *arg3, &res, backend_verrou_context); + interflop_check_float_max_sub_double(res_temp, *arg3, &res, backend_check_float_max_context); +}else{ + interflop_verrou_madd_double(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_double(*arg1, *arg2, - *arg3, &res, backend_check_float_max_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +/*static VG_REGPARM(3) Long vr_unfused_conv_verroucheck_float_max_softmsub64F (Long a, Long b, Long c) {*/ +/*if(vr.instrument_soft){*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* float arg1f=*arg1;*/ +/* float arg2f=*arg2;*/ +/* float arg3f=*arg3;*/ + +/* double res;*/ +/* float resf;*/ +/* float res_temp;*/ +/* interflop_verrou_mul_float(arg1f, arg2f, &res_temp, backend_verrou_context);*/ +/* interflop_check_float_max_mul_float(arg1f, arg2f, &res_temp, backend_check_float_max_context);*/ +/* interflop_verrou_sub_float(res_temp, arg3f, &resf, backend_verrou_context);*/ +/* interflop_check_float_max_sub_float(res_temp, arg3f, &resf, backend_check_float_max_context);*/ +/* res=resf;*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*}else{*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* double res;*/ +/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context);*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*} +} +*/ +static VG_REGPARM(3) Int vr_unfused_verroucheck_float_max_softmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_check_float_max_mul_float(*arg1, *arg2, &res_temp, backend_check_float_max_context); + interflop_verrou_sub_float(res_temp, *arg3, &res, backend_verrou_context); + interflop_check_float_max_sub_float(res_temp, *arg3, &res, backend_check_float_max_context); +}else{ + interflop_verrou_madd_float(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_check_float_max_madd_float(*arg1, *arg2, - *arg3, &res, backend_check_float_max_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_NEARESTmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_NEARESTmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_NEAREST(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_NEARESTmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_NEARESTmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_NEAREST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_NEAREST(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_NEARESTmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_NEAREST(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_NEAREST(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_NEARESTmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_NEAREST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_NEAREST(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_UPWARDmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_UPWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_UPWARDmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_UPWARD(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_UPWARDmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_UPWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_UPWARDmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_UPWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_UPWARD(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_UPWARDmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_UPWARD(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_UPWARD(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_UPWARDmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_UPWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_UPWARD(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_DOWNWARDmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_DOWNWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARDmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_DOWNWARD(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_DOWNWARDmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_DOWNWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_DOWNWARDmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_DOWNWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_DOWNWARD(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_DOWNWARDmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_DOWNWARD(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_DOWNWARD(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_DOWNWARDmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_DOWNWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_DOWNWARD(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_FARTHESTmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_FARTHEST(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_FARTHESTmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_FARTHEST(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_FARTHESTmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_FARTHEST(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_FARTHESTmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_FARTHEST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_FARTHEST(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_FARTHESTmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_FARTHEST(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_FARTHEST(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_FARTHESTmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_FARTHEST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_FARTHEST(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_ZEROmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_ZEROmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_ZERO(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_ZEROmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_ZEROmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_ZERO(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_ZEROmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_ZERO(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_ZERO(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_ZEROmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_ZERO(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_AWAY_ZEROmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_AWAY_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZEROmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AWAY_ZERO(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_AWAY_ZEROmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_AWAY_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AWAY_ZEROmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_AWAY_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_AWAY_ZERO(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AWAY_ZEROmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AWAY_ZERO(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AWAY_ZERO(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AWAY_ZEROmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_AWAY_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AWAY_ZERO(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOMmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_RANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_RANDOMmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_RANDOM(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_RANDOMmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_RANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOMmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_RANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_RANDOM(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOMmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_RANDOM(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOMmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_RANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_RANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_RANDOM_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_RANDOM_DETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_RANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_RANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_RANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_RANDOM_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_DET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_DETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_RANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_RANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_RANDOM_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_RANDOM_COMDETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_RANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_RANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_RANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_RANDOM_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_COMDET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_COMDETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_RANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGEmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_AVERAGE(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGEmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AVERAGE(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_AVERAGEmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_AVERAGE(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGEmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_AVERAGE(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_AVERAGE(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGEmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AVERAGE(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGEmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_AVERAGE(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_AVERAGE_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AVERAGE_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_AVERAGE_DETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_AVERAGE_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_AVERAGE_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_AVERAGE_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AVERAGE_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_DET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_DETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_AVERAGE_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_AVERAGE_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AVERAGE_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_AVERAGE_COMDETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_AVERAGE_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_AVERAGE_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_AVERAGE_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AVERAGE_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_COMDET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_COMDETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_AVERAGE_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_PRANDOMmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_PRANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOMmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_PRANDOM(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_PRANDOMmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_PRANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOMmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_PRANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_PRANDOM(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOMmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_PRANDOM(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOMmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_PRANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_PRANDOM_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_PRANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_PRANDOM_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_PRANDOM_DETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_PRANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOM_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_PRANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_PRANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOM_DETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_PRANDOM_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM_DET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOM_DETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_PRANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_PRANDOM_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_PRANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_PRANDOM_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_PRANDOM_COMDETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_PRANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOM_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_PRANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_PRANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOM_COMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_PRANDOM_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM_COMDET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOM_COMDETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_PRANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_SCOMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_RANDOM_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_RANDOM_SCOMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_RANDOM_SCOMDETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_RANDOM_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_SCOMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_RANDOM_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_RANDOM_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_SCOMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_RANDOM_SCOMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_SCOMDET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_SCOMDETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_RANDOM_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_SCOMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_AVERAGE_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AVERAGE_SCOMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_AVERAGE_SCOMDETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_AVERAGE_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_SCOMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_AVERAGE_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_AVERAGE_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_SCOMDETmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AVERAGE_SCOMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_SCOMDET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_SCOMDETmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_AVERAGE_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_SR_MONOTONICmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_SR_MONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_SR_MONOTONICmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_SR_MONOTONIC(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_SR_MONOTONICmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_SR_MONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_SR_MONOTONICmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_SR_MONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_SR_MONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_SR_MONOTONICmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_SR_MONOTONIC(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_SR_MONOTONIC(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_SR_MONOTONICmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_SR_MONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_SR_MONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_SR_SMONOTONICmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_SR_SMONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONICmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_SR_SMONOTONIC(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_SR_SMONOTONICmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_SR_SMONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_SR_SMONOTONICmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_SR_SMONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_SR_SMONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_SR_SMONOTONICmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_SR_SMONOTONIC(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_SR_SMONOTONIC(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_SR_SMONOTONICmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_SR_SMONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_SR_SMONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_NEARESTmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_NEARESTmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_NEAREST(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_NEARESTmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_NEARESTmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_NEAREST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_NEAREST(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_NEARESTmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_NEAREST(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_NEAREST(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_NEARESTmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_NEAREST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_NEAREST(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_UPWARDmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_UPWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_UPWARDmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_UPWARD(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_UPWARDmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_UPWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_UPWARDmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_UPWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_UPWARD(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_UPWARDmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_UPWARD(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_UPWARD(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_UPWARDmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_UPWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_UPWARD(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_DOWNWARDmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_DOWNWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARDmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_DOWNWARD(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_DOWNWARDmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_DOWNWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_DOWNWARDmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_DOWNWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_DOWNWARD(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_DOWNWARDmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_DOWNWARD(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_DOWNWARD(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_DOWNWARDmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_DOWNWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_DOWNWARD(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_FARTHESTmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_FARTHEST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_FARTHESTmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_FARTHEST(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_FARTHESTmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_FARTHEST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_FARTHESTmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_FARTHEST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_FARTHEST(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_FARTHESTmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_FARTHEST(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_FARTHEST(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_FARTHESTmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_FARTHEST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_FARTHEST(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_ZEROmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_ZEROmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_ZERO(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_ZEROmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_ZEROmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_ZERO(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_ZEROmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_ZERO(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_ZERO(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_ZEROmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_ZERO(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_AWAY_ZEROmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_AWAY_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZEROmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AWAY_ZERO(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_AWAY_ZEROmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_AWAY_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AWAY_ZEROmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_AWAY_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_AWAY_ZERO(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AWAY_ZEROmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AWAY_ZERO(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AWAY_ZERO(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AWAY_ZEROmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_AWAY_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AWAY_ZERO(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOMmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_RANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_RANDOMmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_RANDOM(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_RANDOMmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_RANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOMmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_RANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_RANDOM(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOMmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_RANDOM(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOMmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_RANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_RANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_RANDOM_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_RANDOM_DETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_RANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_RANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_RANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_RANDOM_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_DET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_DETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_RANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_RANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_RANDOM_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_RANDOM_COMDETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_RANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_RANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_RANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_RANDOM_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_COMDET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_COMDETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_RANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGEmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_AVERAGE(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGEmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AVERAGE(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_AVERAGEmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_AVERAGE(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGEmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_AVERAGE(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_AVERAGE(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGEmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AVERAGE(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGEmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_AVERAGE(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_AVERAGE_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AVERAGE_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_AVERAGE_DETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_AVERAGE_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_AVERAGE_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_AVERAGE_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AVERAGE_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_DET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_DETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_AVERAGE_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_AVERAGE_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AVERAGE_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_AVERAGE_COMDETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_AVERAGE_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_AVERAGE_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_AVERAGE_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AVERAGE_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_COMDET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_COMDETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_AVERAGE_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_PRANDOMmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_PRANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOMmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_PRANDOM(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_PRANDOMmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_PRANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOMmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_PRANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_PRANDOM(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOMmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_PRANDOM(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOMmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_PRANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_PRANDOM_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_PRANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_PRANDOM_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_PRANDOM_DETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_PRANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOM_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_PRANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_PRANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOM_DETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_PRANDOM_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM_DET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOM_DETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_PRANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_PRANDOM_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_PRANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_PRANDOM_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_PRANDOM_COMDETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_PRANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOM_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_PRANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_PRANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOM_COMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_PRANDOM_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM_COMDET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOM_COMDETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_PRANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_SCOMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_RANDOM_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_RANDOM_SCOMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_RANDOM_SCOMDETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_RANDOM_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_SCOMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_RANDOM_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_RANDOM_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_SCOMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_RANDOM_SCOMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_SCOMDET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_SCOMDETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_RANDOM_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_SCOMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_AVERAGE_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AVERAGE_SCOMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_AVERAGE_SCOMDETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_AVERAGE_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_SCOMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_AVERAGE_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_AVERAGE_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_SCOMDETmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AVERAGE_SCOMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_SCOMDET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_SCOMDETmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_AVERAGE_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_SR_MONOTONICmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_SR_MONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_SR_MONOTONICmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_SR_MONOTONIC(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_SR_MONOTONICmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_SR_MONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_SR_MONOTONICmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_SR_MONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_SR_MONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_SR_MONOTONICmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_SR_MONOTONIC(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_SR_MONOTONIC(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_SR_MONOTONICmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_SR_MONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_SR_MONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_SR_SMONOTONICmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_SR_SMONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONICmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_SR_SMONOTONIC(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + + +static VG_REGPARM(3) Int vr_verrou_SR_SMONOTONICmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + interflop_verrou_madd_float_SR_SMONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_SR_SMONOTONICmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + interflop_verrou_mul_double_SR_SMONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_SR_SMONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_SR_SMONOTONICmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_SR_SMONOTONIC(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_SR_SMONOTONIC(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int vr_unfused_verrou_SR_SMONOTONICmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + interflop_verrou_mul_float_SR_SMONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_SR_SMONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +/*static VG_REGPARM(3) Long vr_verrou_NEAREST_softmadd64F (Long a, Long b, Long c) {*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* double res;*/ +/*if(vr.instrument_soft){*/ +/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_context);*/ +/*}else{*/ +/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context);*/ +/*}*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*}*/ + +static VG_REGPARM(3) Long vr_conv_verrou_NEAREST_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_NEAREST(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +/*static VG_REGPARM(3) Int vr_verrou_NEAREST_softmadd32F (Long a, Long b, Long c) {*/ +/*#ifdef USE_VERROU_FMA*/ +/* float *arg1 = (float*)(&a);*/ +/* float *arg2 = (float*)(&b);*/ +/* float *arg3 = (float*)(&c);*/ +/* float res;*/ +/*if(vr.instrument_soft){*/ +/* interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_context);*/ +/*}else{*/ +/* interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context);*/ +/*}*/ +/*#else*/ +/* float res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Int *d = (Int*)(&res);*/ +/* return *d;*/ +/*}*/ + +/*//unFusED vERSION*/ + +static VG_REGPARM(3) Long vr_unfused_verrou_NEAREST_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_NEAREST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_NEAREST(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_NEAREST_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_NEAREST(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_NEAREST(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_verrou_NEAREST_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_NEAREST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_NEAREST(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_UPWARD_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double_UPWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_UPWARD_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_UPWARD(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_verrou_UPWARD_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float_UPWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_UPWARD_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_UPWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_UPWARD(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_UPWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_UPWARD_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_UPWARD(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_UPWARD(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_verrou_UPWARD_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_UPWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_UPWARD(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_UPWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_DOWNWARD_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double_DOWNWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARD_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_DOWNWARD(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_verrou_DOWNWARD_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float_DOWNWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_DOWNWARD_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_DOWNWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_DOWNWARD(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_DOWNWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_DOWNWARD_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_DOWNWARD(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_DOWNWARD(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_verrou_DOWNWARD_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_DOWNWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_DOWNWARD(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_DOWNWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_FARTHEST_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double_FARTHEST(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_FARTHEST_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_FARTHEST(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_verrou_FARTHEST_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float_FARTHEST(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_FARTHEST_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_FARTHEST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_FARTHEST(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_FARTHEST(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_FARTHEST_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_FARTHEST(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_FARTHEST(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_verrou_FARTHEST_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_FARTHEST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_FARTHEST(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_FARTHEST(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_ZERO_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_ZERO_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_ZERO(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_verrou_ZERO_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_ZERO_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_ZERO(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_ZERO_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_ZERO(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_ZERO(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_verrou_ZERO_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_ZERO(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_AWAY_ZERO_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double_AWAY_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZERO_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AWAY_ZERO(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_verrou_AWAY_ZERO_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float_AWAY_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AWAY_ZERO_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_AWAY_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_AWAY_ZERO(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_AWAY_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AWAY_ZERO_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AWAY_ZERO(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AWAY_ZERO(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AWAY_ZERO_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_AWAY_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AWAY_ZERO(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_AWAY_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double_RANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_RANDOM(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_verrou_RANDOM_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float_RANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_RANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_RANDOM(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_RANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_RANDOM(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_RANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_RANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_DET_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double_RANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_RANDOM_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_verrou_RANDOM_DET_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float_RANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_DET_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_RANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_RANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_RANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_DET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_RANDOM_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_DET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_DET_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_RANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_RANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double_RANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_RANDOM_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_verrou_RANDOM_COMDET_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float_RANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_RANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_RANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_RANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_RANDOM_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_COMDET(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_COMDET_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_RANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_RANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double_AVERAGE(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AVERAGE(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_verrou_AVERAGE_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float_AVERAGE(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_AVERAGE(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_AVERAGE(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_AVERAGE(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_AVERAGE(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_AVERAGE(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_AVERAGE(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_DET_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double_AVERAGE_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + interflop_verrou_madd_float_AVERAGE_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_verrou_AVERAGE_DET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_float_AVERAGE_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39760,14 +46622,22 @@ static VG_REGPARM(3) Int vr_verrou_NEARESTmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_UPWARDmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_DET_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_UPWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_AVERAGE_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_AVERAGE_DET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_AVERAGE_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39776,7 +46646,8 @@ static VG_REGPARM(3) Long vr_verrou_UPWARDmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_UPWARDmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_DET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39787,7 +46658,9 @@ static VG_REGPARM(3) Long vr_conv_verrou_UPWARDmsub64F (Long a, Long b, Long c) double res; float resf; - interflop_verrou_madd_float_UPWARD(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_AVERAGE_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_DET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -39795,16 +46668,35 @@ static VG_REGPARM(3) Long vr_conv_verrou_UPWARDmsub64F (Long a, Long b, Long c) #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_UPWARDmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_DET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_UPWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_AVERAGE_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_DET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_AVERAGE_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39812,14 +46704,18 @@ static VG_REGPARM(3) Int vr_verrou_UPWARDmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_DOWNWARDmsub64F (Long a, Long b, Long c) { +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_COMDET_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_DOWNWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_double_AVERAGE_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39828,7 +46724,8 @@ static VG_REGPARM(3) Long vr_verrou_DOWNWARDmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARDmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39839,7 +46736,7 @@ static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARDmsub64F (Long a, Long b, Long c double res; float resf; - interflop_verrou_madd_float_DOWNWARD(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_AVERAGE_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -39847,16 +46744,33 @@ static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARDmsub64F (Long a, Long b, Long c #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_DOWNWARDmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_AVERAGE_COMDET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_DOWNWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_float_AVERAGE_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39864,14 +46778,22 @@ static VG_REGPARM(3) Int vr_verrou_DOWNWARDmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_FARTHESTmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_COMDET_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_FARTHEST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_AVERAGE_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_AVERAGE_COMDET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_AVERAGE_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39880,7 +46802,8 @@ static VG_REGPARM(3) Long vr_verrou_FARTHESTmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_FARTHESTmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_COMDET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39891,7 +46814,9 @@ static VG_REGPARM(3) Long vr_conv_verrou_FARTHESTmsub64F (Long a, Long b, Long c double res; float resf; - interflop_verrou_madd_float_FARTHEST(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_AVERAGE_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_COMDET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -39899,16 +46824,35 @@ static VG_REGPARM(3) Long vr_conv_verrou_FARTHESTmsub64F (Long a, Long b, Long c #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_FARTHESTmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_COMDET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_FARTHEST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_AVERAGE_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_COMDET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_AVERAGE_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39916,14 +46860,18 @@ static VG_REGPARM(3) Int vr_verrou_FARTHESTmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_ZEROmsub64F (Long a, Long b, Long c) { +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_PRANDOM_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_double_PRANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39932,7 +46880,8 @@ static VG_REGPARM(3) Long vr_verrou_ZEROmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_ZEROmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39943,7 +46892,7 @@ static VG_REGPARM(3) Long vr_conv_verrou_ZEROmsub64F (Long a, Long b, Long c) { double res; float resf; - interflop_verrou_madd_float_ZERO(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_PRANDOM(arg1f, arg2f, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -39951,16 +46900,115 @@ static VG_REGPARM(3) Long vr_conv_verrou_ZEROmsub64F (Long a, Long b, Long c) { #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_verrou_PRANDOM_softmadd32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float_PRANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; } +//unFusED vERSION -static VG_REGPARM(3) Int vr_verrou_ZEROmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOM_softmadd64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_PRANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_PRANDOM(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_PRANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOM_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_PRANDOM(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} +} + +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOM_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_PRANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_PRANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39968,14 +47016,18 @@ static VG_REGPARM(3) Int vr_verrou_ZEROmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_AWAY_ZEROmsub64F (Long a, Long b, Long c) { +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_PRANDOM_DET_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_AWAY_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_double_PRANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -39984,7 +47036,8 @@ static VG_REGPARM(3) Long vr_verrou_AWAY_ZEROmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZEROmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -39994,9 +47047,22 @@ static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZEROmsub64F (Long a, Long b, Long float arg3f=*arg3; double res; - float resf; - interflop_verrou_madd_float_AWAY_ZERO(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); - res=resf; + float resf; + interflop_verrou_madd_float_PRANDOM_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40004,15 +47070,19 @@ static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZEROmsub64F (Long a, Long b, Long Long *d = (Long*)(&res); return *d; } +} - -static VG_REGPARM(3) Int vr_verrou_AWAY_ZEROmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_PRANDOM_DET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_AWAY_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_float_PRANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40020,14 +47090,22 @@ static VG_REGPARM(3) Int vr_verrou_AWAY_ZEROmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOMmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOM_DET_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_RANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_PRANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_PRANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_PRANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40036,7 +47114,8 @@ static VG_REGPARM(3) Long vr_verrou_RANDOMmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOMmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOM_DET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40047,7 +47126,9 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOMmsub64F (Long a, Long b, Long c) double res; float resf; - interflop_verrou_madd_float_RANDOM(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_PRANDOM_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM_DET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40055,16 +47136,35 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOMmsub64F (Long a, Long b, Long c) #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_RANDOMmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOM_DET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_RANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_PRANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_PRANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40072,14 +47172,18 @@ static VG_REGPARM(3) Int vr_verrou_RANDOMmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_DETmsub64F (Long a, Long b, Long c) { +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_PRANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_RANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_double_PRANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40088,7 +47192,8 @@ static VG_REGPARM(3) Long vr_verrou_RANDOM_DETmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DETmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40099,7 +47204,7 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DETmsub64F (Long a, Long b, Long double res; float resf; - interflop_verrou_madd_float_RANDOM_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_PRANDOM_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40107,16 +47212,33 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DETmsub64F (Long a, Long b, Long #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_RANDOM_DETmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_PRANDOM_COMDET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_RANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_float_PRANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40124,14 +47246,22 @@ static VG_REGPARM(3) Int vr_verrou_RANDOM_DETmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_COMDETmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_RANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_PRANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_PRANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_PRANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40140,7 +47270,8 @@ static VG_REGPARM(3) Long vr_verrou_RANDOM_COMDETmsub64F (Long a, Long b, Long c return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDETmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40151,7 +47282,9 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDETmsub64F (Long a, Long b, L double res; float resf; - interflop_verrou_madd_float_RANDOM_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_PRANDOM_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM_COMDET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40159,16 +47292,35 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDETmsub64F (Long a, Long b, L #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_RANDOM_COMDETmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOM_COMDET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_RANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_PRANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_PRANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_PRANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40176,14 +47328,18 @@ static VG_REGPARM(3) Int vr_verrou_RANDOM_COMDETmsub32F (Long a, Long b, Long c) Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGEmsub64F (Long a, Long b, Long c) { +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_SCOMDET_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_AVERAGE(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_double_RANDOM_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40192,7 +47348,8 @@ static VG_REGPARM(3) Long vr_verrou_AVERAGEmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGEmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40203,7 +47360,7 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGEmsub64F (Long a, Long b, Long c) double res; float resf; - interflop_verrou_madd_float_AVERAGE(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_RANDOM_SCOMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40211,16 +47368,33 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGEmsub64F (Long a, Long b, Long c) #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_AVERAGEmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_RANDOM_SCOMDET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_AVERAGE(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_float_RANDOM_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40228,14 +47402,22 @@ static VG_REGPARM(3) Int vr_verrou_AVERAGEmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_DETmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_SCOMDET_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_AVERAGE_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_RANDOM_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_RANDOM_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_RANDOM_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40244,7 +47426,8 @@ static VG_REGPARM(3) Long vr_verrou_AVERAGE_DETmsub64F (Long a, Long b, Long c) return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DETmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_SCOMDET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40255,7 +47438,9 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DETmsub64F (Long a, Long b, Lon double res; float resf; - interflop_verrou_madd_float_AVERAGE_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_RANDOM_SCOMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_SCOMDET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40263,16 +47448,35 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DETmsub64F (Long a, Long b, Lon #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_AVERAGE_DETmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_SCOMDET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_AVERAGE_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_RANDOM_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_RANDOM_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_RANDOM_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40280,14 +47484,18 @@ static VG_REGPARM(3) Int vr_verrou_AVERAGE_DETmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_COMDETmsub64F (Long a, Long b, Long c) { +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_SCOMDET_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_AVERAGE_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_double_AVERAGE_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40296,7 +47504,8 @@ static VG_REGPARM(3) Long vr_verrou_AVERAGE_COMDETmsub64F (Long a, Long b, Long return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDETmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40307,7 +47516,7 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDETmsub64F (Long a, Long b, double res; float resf; - interflop_verrou_madd_float_AVERAGE_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_AVERAGE_SCOMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40315,16 +47524,33 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDETmsub64F (Long a, Long b, #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_AVERAGE_COMDETmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_AVERAGE_SCOMDET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_AVERAGE_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_float_AVERAGE_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40332,14 +47558,22 @@ static VG_REGPARM(3) Int vr_verrou_AVERAGE_COMDETmsub32F (Long a, Long b, Long c Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOMmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_SCOMDET_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_PRANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_AVERAGE_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_AVERAGE_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_AVERAGE_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40348,7 +47582,8 @@ static VG_REGPARM(3) Long vr_verrou_PRANDOMmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOMmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_SCOMDET_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40359,7 +47594,9 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOMmsub64F (Long a, Long b, Long c) double res; float resf; - interflop_verrou_madd_float_PRANDOM(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_AVERAGE_SCOMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_SCOMDET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40367,16 +47604,35 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOMmsub64F (Long a, Long b, Long c) #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_PRANDOMmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_SCOMDET_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_PRANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_AVERAGE_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_AVERAGE_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_AVERAGE_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40384,14 +47640,18 @@ static VG_REGPARM(3) Int vr_verrou_PRANDOMmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOM_DETmsub64F (Long a, Long b, Long c) { +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_SR_MONOTONIC_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_PRANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_double_SR_MONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40400,7 +47660,8 @@ static VG_REGPARM(3) Long vr_verrou_PRANDOM_DETmsub64F (Long a, Long b, Long c) return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DETmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_SR_MONOTONIC_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40411,7 +47672,7 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DETmsub64F (Long a, Long b, Lon double res; float resf; - interflop_verrou_madd_float_PRANDOM_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_SR_MONOTONIC(arg1f, arg2f, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40419,16 +47680,33 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DETmsub64F (Long a, Long b, Lon #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_PRANDOM_DETmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_SR_MONOTONIC_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_PRANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_float_SR_MONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40436,14 +47714,22 @@ static VG_REGPARM(3) Int vr_verrou_PRANDOM_DETmsub32F (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOM_COMDETmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_SR_MONOTONIC_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_PRANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_SR_MONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_SR_MONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_SR_MONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40452,7 +47738,8 @@ static VG_REGPARM(3) Long vr_verrou_PRANDOM_COMDETmsub64F (Long a, Long b, Long return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDETmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_SR_MONOTONIC_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40463,7 +47750,9 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDETmsub64F (Long a, Long b, double res; float resf; - interflop_verrou_madd_float_PRANDOM_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_SR_MONOTONIC(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_SR_MONOTONIC(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40471,16 +47760,35 @@ static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDETmsub64F (Long a, Long b, #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_PRANDOM_COMDETmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_SR_MONOTONIC_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_PRANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_SR_MONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_SR_MONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_SR_MONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40488,14 +47796,18 @@ static VG_REGPARM(3) Int vr_verrou_PRANDOM_COMDETmsub32F (Long a, Long b, Long c Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_SCOMDETmsub64F (Long a, Long b, Long c) { +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_SR_SMONOTONIC_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_RANDOM_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_double_SR_SMONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40504,7 +47816,8 @@ static VG_REGPARM(3) Long vr_verrou_RANDOM_SCOMDETmsub64F (Long a, Long b, Long return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDETmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONIC_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40515,7 +47828,7 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDETmsub64F (Long a, Long b, double res; float resf; - interflop_verrou_madd_float_RANDOM_SCOMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_SR_SMONOTONIC(arg1f, arg2f, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40523,16 +47836,33 @@ static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDETmsub64F (Long a, Long b, #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_RANDOM_SCOMDETmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_SR_SMONOTONIC_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_RANDOM_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +if(vr.instrument_soft){ + interflop_verrou_madd_float_SR_SMONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40540,14 +47870,22 @@ static VG_REGPARM(3) Int vr_verrou_RANDOM_SCOMDETmsub32F (Long a, Long b, Long c Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_SCOMDETmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_SR_SMONOTONIC_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_AVERAGE_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_SR_SMONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_SR_SMONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_SR_SMONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40556,7 +47894,8 @@ static VG_REGPARM(3) Long vr_verrou_AVERAGE_SCOMDETmsub64F (Long a, Long b, Long return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDETmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_SR_SMONOTONIC_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40567,7 +47906,9 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDETmsub64F (Long a, Long b, double res; float resf; - interflop_verrou_madd_float_AVERAGE_SCOMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_SR_SMONOTONIC(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_SR_SMONOTONIC(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40575,16 +47916,35 @@ static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDETmsub64F (Long a, Long b, #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_AVERAGE_SCOMDETmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_SR_SMONOTONIC_softmadd32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_AVERAGE_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_SR_SMONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_float_SR_SMONOTONIC(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_SR_SMONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40593,34 +47953,52 @@ static VG_REGPARM(3) Int vr_verrou_AVERAGE_SCOMDETmsub32F (Long a, Long b, Long return *d; } // generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_SR_MONOTONICmsub64F (Long a, Long b, Long c) { +/*static VG_REGPARM(3) Long vr_verrou_NEAREST_softmsub64F (Long a, Long b, Long c) {*/ +/*#ifdef USE_VERROU_FMA*/ +/* double *arg1 = (double*)(&a);*/ +/* double *arg2 = (double*)(&b);*/ +/* double *arg3 = (double*)(&c);*/ +/* double res;*/ +/*if(vr.instrument_soft){*/ +/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_context);*/ +/*}else{*/ +/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context);*/ +/*}*/ +/*#else*/ +/* double res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Long *d = (Long*)(&res);*/ +/* return *d;*/ +/*}*/ + +static VG_REGPARM(3) Long vr_conv_verrou_NEAREST_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + double res; - interflop_verrou_madd_double_SR_MONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float resf; + interflop_verrou_madd_float_NEAREST(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + res=resf; #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); #endif Long *d = (Long*)(&res); return *d; -} - -static VG_REGPARM(3) Long vr_conv_verrou_SR_MONOTONICmsub64F (Long a, Long b, Long c) { +}else{ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); - float arg1f=*arg1; - float arg2f=*arg2; - float arg3f=*arg3; - double res; - float resf; - interflop_verrou_madd_float_SR_MONOTONIC(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); - res=resf; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40628,30 +48006,42 @@ static VG_REGPARM(3) Long vr_conv_verrou_SR_MONOTONICmsub64F (Long a, Long b, Lo Long *d = (Long*)(&res); return *d; } +} +/*static VG_REGPARM(3) Int vr_verrou_NEAREST_softmsub32F (Long a, Long b, Long c) {*/ +/*#ifdef USE_VERROU_FMA*/ +/* float *arg1 = (float*)(&a);*/ +/* float *arg2 = (float*)(&b);*/ +/* float *arg3 = (float*)(&c);*/ +/* float res;*/ +/*if(vr.instrument_soft){*/ +/* interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_context);*/ +/*}else{*/ +/* interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context);*/ +/*}*/ +/*#else*/ +/* float res=0.;*/ +/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ +/*#endif*/ +/* Int *d = (Int*)(&res);*/ +/* return *d;*/ +/*}*/ -static VG_REGPARM(3) Int vr_verrou_SR_MONOTONICmsub32F (Long a, Long b, Long c) { -#ifdef USE_VERROU_FMA - float *arg1 = (float*)(&a); - float *arg2 = (float*)(&b); - float *arg3 = (float*)(&c); - float res; - interflop_verrou_madd_float_SR_MONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); -#else - float res=0.; - VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); -#endif - Int *d = (Int*)(&res); - return *d; -} -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_SR_SMONOTONICmsub64F (Long a, Long b, Long c) { +/*//unFusED vERSION*/ + +static VG_REGPARM(3) Long vr_unfused_verrou_NEAREST_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_SR_SMONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_NEAREST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_NEAREST(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40660,7 +48050,8 @@ static VG_REGPARM(3) Long vr_verrou_SR_SMONOTONICmsub64F (Long a, Long b, Long c return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONICmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_NEAREST_softmsub64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -40671,7 +48062,9 @@ static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONICmsub64F (Long a, Long b, L double res; float resf; - interflop_verrou_madd_float_SR_SMONOTONIC(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_NEAREST(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_NEAREST(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40679,16 +48072,35 @@ static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONICmsub64F (Long a, Long b, L #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -static VG_REGPARM(3) Int vr_verrou_SR_SMONOTONICmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_NEAREST_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; - interflop_verrou_madd_float_SR_SMONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_NEAREST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_NEAREST(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +} #else float res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40696,27 +48108,27 @@ static VG_REGPARM(3) Int vr_verrou_SR_SMONOTONICmsub32F (Long a, Long b, Long c) Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -/*static VG_REGPARM(3) Long vr_verrou_NEAREST_softmadd64F (Long a, Long b, Long c) {*/ -/*#ifdef USE_VERROU_FMA*/ -/* double *arg1 = (double*)(&a);*/ -/* double *arg2 = (double*)(&b);*/ -/* double *arg3 = (double*)(&c);*/ -/* double res;*/ -/*if(vr.instrument_soft){*/ -/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_context);*/ -/*}else{*/ -/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context);*/ -/*}*/ -/*#else*/ -/* double res=0.;*/ -/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ -/*#endif*/ -/* Long *d = (Long*)(&res);*/ -/* return *d;*/ -/*}*/ +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_UPWARD_softmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; +if(vr.instrument_soft){ + interflop_verrou_madd_double_UPWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} -static VG_REGPARM(3) Long vr_conv_verrou_NEAREST_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_UPWARD_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -40728,7 +48140,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_NEAREST(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_UPWARD(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40742,7 +48154,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40752,35 +48164,39 @@ if(vr.instrument_soft){ } } -/*static VG_REGPARM(3) Int vr_verrou_NEAREST_softmadd32F (Long a, Long b, Long c) {*/ -/*#ifdef USE_VERROU_FMA*/ -/* float *arg1 = (float*)(&a);*/ -/* float *arg2 = (float*)(&b);*/ -/* float *arg3 = (float*)(&c);*/ -/* float res;*/ -/*if(vr.instrument_soft){*/ -/* interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_context);*/ -/*}else{*/ -/* interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context);*/ -/*}*/ -/*#else*/ -/* float res=0.;*/ -/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ -/*#endif*/ -/* Int *d = (Int*)(&res);*/ -/* return *d;*/ -/*}*/ -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_UPWARD_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_UPWARD_softmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; +if(vr.instrument_soft){ + interflop_verrou_madd_float_UPWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_UPWARD_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_UPWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_UPWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_UPWARD(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_UPWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -40790,7 +48206,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_UPWARD_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_UPWARD_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -40802,7 +48218,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_UPWARD(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_UPWARD(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_UPWARD(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40816,7 +48234,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40826,16 +48244,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_UPWARD_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_UPWARD_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_UPWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_UPWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_UPWARD(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_UPWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -40844,17 +48264,17 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_DOWNWARD_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_DOWNWARD_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_DOWNWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_DOWNWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else double res=0.; @@ -40864,7 +48284,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARD_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARD_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -40876,7 +48296,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_DOWNWARD(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_DOWNWARD(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40890,7 +48310,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40900,16 +48320,16 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_DOWNWARD_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_DOWNWARD_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_DOWNWARD(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_DOWNWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else float res=0.; @@ -40918,17 +48338,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_FARTHEST_softmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_DOWNWARD_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_FARTHEST(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_DOWNWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_DOWNWARD(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_DOWNWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -40938,7 +48362,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_FARTHEST_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_DOWNWARD_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -40950,7 +48374,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_FARTHEST(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_DOWNWARD(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_DOWNWARD(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -40964,7 +48390,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -40974,16 +48400,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_FARTHEST_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_DOWNWARD_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_FARTHEST(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_DOWNWARD(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_DOWNWARD(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_DOWNWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -40992,17 +48420,17 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_ZERO_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_FARTHEST_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_FARTHEST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else double res=0.; @@ -41012,7 +48440,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_ZERO_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_FARTHEST_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41024,7 +48452,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_ZERO(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_FARTHEST(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41038,7 +48466,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41048,16 +48476,16 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_ZERO_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_FARTHEST_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_FARTHEST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else float res=0.; @@ -41066,17 +48494,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_AWAY_ZERO_softmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_FARTHEST_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_AWAY_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_FARTHEST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_FARTHEST(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_FARTHEST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -41086,7 +48518,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZERO_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_FARTHEST_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41098,7 +48530,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_AWAY_ZERO(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_FARTHEST(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_FARTHEST(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41112,7 +48546,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41122,16 +48556,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_AWAY_ZERO_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_FARTHEST_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_AWAY_ZERO(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_FARTHEST(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_FARTHEST(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_FARTHEST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -41140,17 +48576,17 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_ZERO_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_RANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else double res=0.; @@ -41160,7 +48596,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_ZERO_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41172,7 +48608,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_RANDOM(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_ZERO(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41186,7 +48622,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41196,16 +48632,16 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_RANDOM_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_ZERO_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_RANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else float res=0.; @@ -41214,17 +48650,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_DET_softmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_ZERO_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_RANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_ZERO(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -41234,7 +48674,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DET_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_ZERO_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41246,7 +48686,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_RANDOM_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_ZERO(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_ZERO(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41260,7 +48702,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41270,16 +48712,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_RANDOM_DET_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_ZERO_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_RANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_ZERO(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -41288,17 +48732,17 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_AWAY_ZERO_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_RANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_AWAY_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else double res=0.; @@ -41308,7 +48752,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZERO_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41320,7 +48764,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_RANDOM_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_AWAY_ZERO(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41334,7 +48778,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41344,16 +48788,16 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_RANDOM_COMDET_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_AWAY_ZERO_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_RANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_AWAY_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else float res=0.; @@ -41362,17 +48806,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_softmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AWAY_ZERO_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_AVERAGE(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_AWAY_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_AWAY_ZERO(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_AWAY_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -41382,7 +48830,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AWAY_ZERO_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41394,7 +48842,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_AVERAGE(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_AWAY_ZERO(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AWAY_ZERO(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41408,7 +48858,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41418,16 +48868,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_AVERAGE_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_AWAY_ZERO_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_AVERAGE(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_AWAY_ZERO(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AWAY_ZERO(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_AWAY_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -41436,17 +48888,17 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_DET_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_AVERAGE_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_RANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else double res=0.; @@ -41456,7 +48908,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DET_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41468,7 +48920,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_AVERAGE_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_RANDOM(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41482,7 +48934,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41492,16 +48944,16 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_AVERAGE_DET_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_RANDOM_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_AVERAGE_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_RANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else float res=0.; @@ -41510,17 +48962,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_COMDET_softmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_AVERAGE_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_RANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_RANDOM(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_RANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -41530,7 +48986,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDET_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41542,7 +48998,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_AVERAGE_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_RANDOM(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41556,7 +49014,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41566,16 +49024,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_AVERAGE_COMDET_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_AVERAGE_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_RANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_RANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -41584,17 +49044,17 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOM_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_DET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_PRANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_RANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else double res=0.; @@ -41604,7 +49064,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41616,7 +49076,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_PRANDOM(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_RANDOM_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41630,7 +49090,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41640,16 +49100,16 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_PRANDOM_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_RANDOM_DET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_PRANDOM(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_RANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else float res=0.; @@ -41658,17 +49118,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOM_DET_softmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_DET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_PRANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_RANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_RANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_RANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -41678,7 +49142,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DET_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_DET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41690,7 +49154,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_PRANDOM_DET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_RANDOM_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_DET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41704,7 +49170,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41714,16 +49180,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_PRANDOM_DET_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_DET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_PRANDOM_DET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_RANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_RANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -41732,17 +49200,17 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_RANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_PRANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_RANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else double res=0.; @@ -41752,7 +49220,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDET_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41764,7 +49232,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_PRANDOM_COMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_RANDOM_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41778,7 +49246,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41788,16 +49256,16 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_PRANDOM_COMDET_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_RANDOM_COMDET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_PRANDOM_COMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_RANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else float res=0.; @@ -41806,17 +49274,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_SCOMDET_softmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_RANDOM_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_RANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_RANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_RANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -41826,7 +49298,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDET_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41838,7 +49310,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_RANDOM_SCOMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_RANDOM_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_COMDET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41852,7 +49326,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41862,16 +49336,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_RANDOM_SCOMDET_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_COMDET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_RANDOM_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_RANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_RANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -41880,17 +49356,17 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_SCOMDET_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_AVERAGE_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_AVERAGE(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else double res=0.; @@ -41900,7 +49376,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDET_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41912,7 +49388,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_AVERAGE_SCOMDET(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_AVERAGE(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -41926,7 +49402,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -41936,16 +49412,16 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_AVERAGE_SCOMDET_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_AVERAGE_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_AVERAGE_SCOMDET(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_AVERAGE(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else float res=0.; @@ -41954,17 +49430,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_SR_MONOTONIC_softmadd64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_SR_MONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_AVERAGE(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_AVERAGE(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_AVERAGE(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -41974,7 +49454,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_SR_MONOTONIC_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -41986,7 +49466,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_SR_MONOTONIC(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_AVERAGE(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42000,7 +49482,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -42010,16 +49492,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_SR_MONOTONIC_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_SR_MONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_AVERAGE(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_AVERAGE(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -42028,17 +49512,17 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_SR_SMONOTONIC_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_AVERAGE_DET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_SR_SMONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_AVERAGE_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else double res=0.; @@ -42048,7 +49532,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONIC_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42060,7 +49544,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_SR_SMONOTONIC(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_AVERAGE_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42074,7 +49558,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -42084,16 +49568,16 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_SR_SMONOTONIC_softmadd32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_AVERAGE_DET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_SR_SMONOTONIC(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_AVERAGE_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else float res=0.; @@ -42102,27 +49586,31 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -/*static VG_REGPARM(3) Long vr_verrou_NEAREST_softmsub64F (Long a, Long b, Long c) {*/ -/*#ifdef USE_VERROU_FMA*/ -/* double *arg1 = (double*)(&a);*/ -/* double *arg2 = (double*)(&b);*/ -/* double *arg3 = (double*)(&c);*/ -/* double res;*/ -/*if(vr.instrument_soft){*/ -/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_context);*/ -/*}else{*/ -/* interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context);*/ -/*}*/ -/*#else*/ -/* double res=0.;*/ -/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ -/*#endif*/ -/* Long *d = (Long*)(&res);*/ -/* return *d;*/ -/*}*/ -static VG_REGPARM(3) Long vr_conv_verrou_NEAREST_softmsub64F (Long a, Long b, Long c) { +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_DET_softmsub64F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_AVERAGE_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_AVERAGE_DET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_AVERAGE_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +} +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_DET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42134,7 +49622,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_NEAREST(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_AVERAGE_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_DET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42148,7 +49638,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -42158,33 +49648,35 @@ if(vr.instrument_soft){ } } -/*static VG_REGPARM(3) Int vr_verrou_NEAREST_softmsub32F (Long a, Long b, Long c) {*/ -/*#ifdef USE_VERROU_FMA*/ -/* float *arg1 = (float*)(&a);*/ -/* float *arg2 = (float*)(&b);*/ -/* float *arg3 = (float*)(&c);*/ -/* float res;*/ -/*if(vr.instrument_soft){*/ -/* interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_context);*/ -/*}else{*/ -/* interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context);*/ -/*}*/ -/*#else*/ -/* float res=0.;*/ -/* VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n");*/ -/*#endif*/ -/* Int *d = (Int*)(&res);*/ -/* return *d;*/ -/*}*/ +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_DET_softmsub32F (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_float_AVERAGE_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_DET(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_float_AVERAGE_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); +} +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} // generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_UPWARD_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verrou_AVERAGE_COMDET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_UPWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_AVERAGE_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42196,7 +49688,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_UPWARD_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42208,7 +49700,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_UPWARD(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_AVERAGE_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42232,14 +49724,14 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_UPWARD_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_AVERAGE_COMDET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_UPWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_AVERAGE_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42250,17 +49742,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_DOWNWARD_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_COMDET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_DOWNWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_AVERAGE_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_AVERAGE_COMDET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_AVERAGE_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -42270,7 +49766,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_DOWNWARD_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_COMDET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42282,7 +49778,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_DOWNWARD(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_AVERAGE_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_COMDET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42296,7 +49794,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -42306,16 +49804,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_DOWNWARD_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_COMDET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_DOWNWARD(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_AVERAGE_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_COMDET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_AVERAGE_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -42325,14 +49825,14 @@ if(vr.instrument_soft){ return *d; } // generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_FARTHEST_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verrou_PRANDOM_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_FARTHEST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_PRANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42344,7 +49844,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_FARTHEST_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42356,7 +49856,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_FARTHEST(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_PRANDOM(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42380,14 +49880,14 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_FARTHEST_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_PRANDOM_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_FARTHEST(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_PRANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42398,17 +49898,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_ZERO_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOM_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_PRANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_PRANDOM(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_PRANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -42418,7 +49922,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_ZERO_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOM_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42430,7 +49934,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_ZERO(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_PRANDOM(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42444,7 +49950,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -42454,16 +49960,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_ZERO_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOM_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_PRANDOM(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_PRANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -42473,14 +49981,14 @@ if(vr.instrument_soft){ return *d; } // generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_AWAY_ZERO_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verrou_PRANDOM_DET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_AWAY_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_PRANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42492,7 +50000,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AWAY_ZERO_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42504,7 +50012,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_AWAY_ZERO(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_PRANDOM_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42528,14 +50036,14 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_AWAY_ZERO_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_PRANDOM_DET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_AWAY_ZERO(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_PRANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42546,17 +50054,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOM_DET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_RANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_PRANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_PRANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_PRANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -42566,7 +50078,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOM_DET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42578,7 +50090,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_RANDOM(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_PRANDOM_DET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM_DET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42592,7 +50106,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -42602,16 +50116,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_RANDOM_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOM_DET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_RANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_PRANDOM_DET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM_DET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_PRANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -42621,14 +50137,14 @@ if(vr.instrument_soft){ return *d; } // generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_DET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verrou_PRANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_RANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_PRANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42640,7 +50156,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_DET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42652,7 +50168,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_RANDOM_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_PRANDOM_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42676,14 +50192,14 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_RANDOM_DET_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_PRANDOM_COMDET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_RANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_PRANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42694,17 +50210,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_PRANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_RANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_PRANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_PRANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_PRANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -42714,7 +50234,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_PRANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42726,7 +50246,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_RANDOM_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_PRANDOM_COMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM_COMDET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42740,7 +50262,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -42750,16 +50272,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_RANDOM_COMDET_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_PRANDOM_COMDET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_RANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_PRANDOM_COMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_PRANDOM_COMDET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_PRANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -42769,14 +50293,14 @@ if(vr.instrument_soft){ return *d; } // generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verrou_RANDOM_SCOMDET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_AVERAGE(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_RANDOM_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42788,7 +50312,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42800,7 +50324,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_AVERAGE(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_RANDOM_SCOMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42824,14 +50348,14 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_AVERAGE_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_RANDOM_SCOMDET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_AVERAGE(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_RANDOM_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42842,17 +50366,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_DET_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_RANDOM_SCOMDET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_AVERAGE_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_RANDOM_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_RANDOM_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_RANDOM_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -42862,7 +50390,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_DET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_RANDOM_SCOMDET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42874,7 +50402,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_AVERAGE_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_RANDOM_SCOMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_SCOMDET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42888,7 +50418,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -42898,16 +50428,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_AVERAGE_DET_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_RANDOM_SCOMDET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_AVERAGE_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_RANDOM_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_RANDOM_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_RANDOM_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -42917,14 +50449,14 @@ if(vr.instrument_soft){ return *d; } // generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_COMDET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verrou_AVERAGE_SCOMDET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_AVERAGE_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_AVERAGE_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42936,7 +50468,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_COMDET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -42948,7 +50480,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_AVERAGE_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_AVERAGE_SCOMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -42972,14 +50504,14 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_AVERAGE_COMDET_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_AVERAGE_SCOMDET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_AVERAGE_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_AVERAGE_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -42990,17 +50522,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOM_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_AVERAGE_SCOMDET_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_PRANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_AVERAGE_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_AVERAGE_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_AVERAGE_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -43010,7 +50546,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_AVERAGE_SCOMDET_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -43022,7 +50558,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_PRANDOM(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_AVERAGE_SCOMDET(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_SCOMDET(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -43036,7 +50574,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -43046,16 +50584,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_PRANDOM_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_AVERAGE_SCOMDET_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_PRANDOM(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_AVERAGE_SCOMDET(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_AVERAGE_SCOMDET(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_AVERAGE_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -43065,14 +50605,14 @@ if(vr.instrument_soft){ return *d; } // generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOM_DET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verrou_SR_MONOTONIC_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_PRANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_SR_MONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -43084,7 +50624,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_DET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_SR_MONOTONIC_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -43096,7 +50636,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_PRANDOM_DET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_SR_MONOTONIC(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -43120,14 +50660,14 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_PRANDOM_DET_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_SR_MONOTONIC_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_PRANDOM_DET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_SR_MONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -43138,17 +50678,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_PRANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_SR_MONOTONIC_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_PRANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_SR_MONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_SR_MONOTONIC(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_SR_MONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -43158,7 +50702,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_PRANDOM_COMDET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_SR_MONOTONIC_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -43170,7 +50714,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_PRANDOM_COMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_SR_MONOTONIC(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_SR_MONOTONIC(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -43184,7 +50730,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -43194,16 +50740,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_PRANDOM_COMDET_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_SR_MONOTONIC_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_PRANDOM_COMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_SR_MONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_SR_MONOTONIC(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_SR_MONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -43213,14 +50761,14 @@ if(vr.instrument_soft){ return *d; } // generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_RANDOM_SCOMDET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verrou_SR_SMONOTONIC_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_RANDOM_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_SR_SMONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -43232,7 +50780,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_RANDOM_SCOMDET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONIC_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -43244,7 +50792,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_RANDOM_SCOMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_SR_SMONOTONIC(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -43268,14 +50816,14 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_RANDOM_SCOMDET_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_verrou_SR_SMONOTONIC_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; if(vr.instrument_soft){ - interflop_verrou_madd_float_RANDOM_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_madd_float_SR_SMONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } @@ -43286,17 +50834,21 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_AVERAGE_SCOMDET_softmsub64F (Long a, Long b, Long c) { + +//unFusED vERSION + +static VG_REGPARM(3) Long vr_unfused_verrou_SR_SMONOTONIC_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_AVERAGE_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_SR_SMONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_SR_SMONOTONIC(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_SR_SMONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -43306,7 +50858,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_AVERAGE_SCOMDET_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_SR_SMONOTONIC_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -43318,7 +50870,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_AVERAGE_SCOMDET(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_SR_SMONOTONIC(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_SR_SMONOTONIC(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -43332,7 +50886,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -43342,16 +50896,18 @@ if(vr.instrument_soft){ } } -static VG_REGPARM(3) Int vr_verrou_AVERAGE_SCOMDET_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Int vr_unfused_verrou_SR_SMONOTONIC_softmsub32F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA float *arg1 = (float*)(&a); float *arg2 = (float*)(&b); float *arg3 = (float*)(&c); float res; + float res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_float_AVERAGE_SCOMDET(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_float_SR_SMONOTONIC(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_SR_SMONOTONIC(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_float_SR_SMONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else float res=0.; @@ -43360,18 +50916,14 @@ if(vr.instrument_soft){ Int *d = (Int*)(&res); return *d; } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_SR_MONOTONIC_softmsub64F (Long a, Long b, Long c) { +// generation of operation madd backend verrou +static VG_REGPARM(3) Long vr_verrou_FLOATmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; -if(vr.instrument_soft){ - interflop_verrou_madd_double_SR_MONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); -}else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + interflop_verrou_madd_double_FLOAT(*arg1, *arg2, *arg3, &res, backend_verrou_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -43380,8 +50932,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_SR_MONOTONIC_softmsub64F (Long a, Long b, Long c) { -if(vr.instrument_soft){ +static VG_REGPARM(3) Long vr_conv_verrou_FLOATmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -43392,7 +50943,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_SR_MONOTONIC(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_FLOAT(arg1f, arg2f, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -43400,13 +50951,18 @@ if(vr.instrument_soft){ #endif Long *d = (Long*)(&res); return *d; -}else{ +} + + +static VG_REGPARM(3) Long vr_unfused_verrou_FLOATmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + double res_temp; + interflop_verrou_mul_double_FLOAT(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_FLOAT(res_temp, *arg3, &res, backend_verrou_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -43414,38 +50970,38 @@ if(vr.instrument_soft){ Long *d = (Long*)(&res); return *d; } -} -static VG_REGPARM(3) Int vr_verrou_SR_MONOTONIC_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_FLOATmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA - float *arg1 = (float*)(&a); - float *arg2 = (float*)(&b); - float *arg3 = (float*)(&c); - float res; -if(vr.instrument_soft){ - interflop_verrou_madd_float_SR_MONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); -}else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_FLOAT(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_FLOAT(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; #else - float res=0.; + double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); #endif - Int *d = (Int*)(&res); + Long *d = (Long*)(&res); return *d; } + // generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_SR_SMONOTONIC_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verrou_FLOATmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; -if(vr.instrument_soft){ - interflop_verrou_madd_double_SR_SMONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); -}else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + interflop_verrou_madd_double_FLOAT(*arg1, *arg2, - *arg3, &res, backend_verrou_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -43454,8 +51010,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_SR_SMONOTONIC_softmsub64F (Long a, Long b, Long c) { -if(vr.instrument_soft){ +static VG_REGPARM(3) Long vr_conv_verrou_FLOATmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -43466,7 +51021,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_SR_SMONOTONIC(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_FLOAT(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -43474,13 +51029,18 @@ if(vr.instrument_soft){ #endif Long *d = (Long*)(&res); return *d; -}else{ +} + + +static VG_REGPARM(3) Long vr_unfused_verrou_FLOATmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + double res_temp; + interflop_verrou_mul_double_FLOAT(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_FLOAT(res_temp, *arg3, &res, backend_verrou_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -43488,34 +51048,42 @@ if(vr.instrument_soft){ Long *d = (Long*)(&res); return *d; } -} -static VG_REGPARM(3) Int vr_verrou_SR_SMONOTONIC_softmsub32F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_FLOATmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA - float *arg1 = (float*)(&a); - float *arg2 = (float*)(&b); - float *arg3 = (float*)(&c); - float res; -if(vr.instrument_soft){ - interflop_verrou_madd_float_SR_SMONOTONIC(*arg1, *arg2, - *arg3, &res, backend_verrou_context); -}else{ - interflop_verrou_madd_float_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); -} + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + interflop_verrou_mul_float_FLOAT(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_FLOAT(res_temp, arg3f, &resf, backend_verrou_context); + res=resf; #else - float res=0.; + double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); #endif - Int *d = (Int*)(&res); + Long *d = (Long*)(&res); return *d; } + // generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_FLOATmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_verrou_FLOAT_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; +if(vr.instrument_soft){ interflop_verrou_madd_double_FLOAT(*arg1, *arg2, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -43524,7 +51092,8 @@ static VG_REGPARM(3) Long vr_verrou_FLOATmadd64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_FLOATmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_FLOAT_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -43543,17 +51112,35 @@ static VG_REGPARM(3) Long vr_conv_verrou_FLOATmadd64F (Long a, Long b, Long c) { #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_FLOATmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_verrou_FLOAT_softmadd64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_FLOAT(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + double res_temp; +if(vr.instrument_soft){ + interflop_verrou_mul_double_FLOAT(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_add_double_FLOAT(res_temp, *arg3, &res, backend_verrou_context); +}else{ + interflop_verrou_madd_double_FLOAT(*arg1, *arg2, *arg3, &res, backend_verrou_context); +} #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -43562,7 +51149,8 @@ static VG_REGPARM(3) Long vr_verrou_FLOATmsub64F (Long a, Long b, Long c) { return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_FLOATmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_FLOAT_softmadd64F (Long a, Long b, Long c) { +if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); @@ -43573,7 +51161,9 @@ static VG_REGPARM(3) Long vr_conv_verrou_FLOATmsub64F (Long a, Long b, Long c) { double res; float resf; - interflop_verrou_madd_float_FLOAT(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_FLOAT(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_add_float_FLOAT(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -43581,20 +51171,33 @@ static VG_REGPARM(3) Long vr_conv_verrou_FLOATmsub64F (Long a, Long b, Long c) { #endif Long *d = (Long*)(&res); return *d; +}else{ +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} } - -// generation of operation madd backend verrou -static VG_REGPARM(3) Long vr_verrou_FLOAT_softmadd64F (Long a, Long b, Long c) { +// generation of operation msub backend verrou +static VG_REGPARM(3) Long vr_verrou_FLOAT_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; if(vr.instrument_soft){ - interflop_verrou_madd_double_FLOAT(*arg1, *arg2, *arg3, &res, backend_verrou_context); + interflop_verrou_madd_double_FLOAT(*arg1, *arg2, - *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); } #else double res=0.; @@ -43604,7 +51207,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_FLOAT_softmadd64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_conv_verrou_FLOAT_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -43616,7 +51219,7 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_FLOAT(arg1f, arg2f, arg3f, &resf, backend_verrou_context); + interflop_verrou_madd_float_FLOAT(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -43630,7 +51233,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); @@ -43640,17 +51243,18 @@ if(vr.instrument_soft){ } } -// generation of operation msub backend verrou -static VG_REGPARM(3) Long vr_verrou_FLOAT_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_verrou_FLOAT_softmsub64F (Long a, Long b, Long c) { #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; + double res_temp; if(vr.instrument_soft){ - interflop_verrou_madd_double_FLOAT(*arg1, *arg2, - *arg3, &res, backend_verrou_context); + interflop_verrou_mul_double_FLOAT(*arg1, *arg2, &res_temp, backend_verrou_context); + interflop_verrou_sub_double_FLOAT(res_temp, *arg3, &res, backend_verrou_context); }else{ - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_FLOAT(*arg1, *arg2, - *arg3, &res, backend_verrou_context); } #else double res=0.; @@ -43660,7 +51264,7 @@ if(vr.instrument_soft){ return *d; } -static VG_REGPARM(3) Long vr_conv_verrou_FLOAT_softmsub64F (Long a, Long b, Long c) { +static VG_REGPARM(3) Long vr_unfused_conv_verrou_FLOAT_softmsub64F (Long a, Long b, Long c) { if(vr.instrument_soft){ #ifdef USE_VERROU_FMA double *arg1 = (double*)(&a); @@ -43672,7 +51276,9 @@ if(vr.instrument_soft){ double res; float resf; - interflop_verrou_madd_float_FLOAT(arg1f, arg2f, - arg3f, &resf, backend_verrou_context); + float res_temp; + interflop_verrou_mul_float_FLOAT(arg1f, arg2f, &res_temp, backend_verrou_context); + interflop_verrou_sub_float_FLOAT(res_temp, arg3f, &resf, backend_verrou_context); res=resf; #else double res=0.; @@ -43686,7 +51292,7 @@ if(vr.instrument_soft){ double *arg2 = (double*)(&b); double *arg3 = (double*)(&c); double res; - interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); + interflop_verrou_madd_double_NEAREST(*arg1, *arg2, - *arg3, &res, backend_verrou_null_context); #else double res=0.; VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); diff --git a/vr_instrumentOp_impl.h b/vr_instrumentOp_impl.h index bbd0099..93cc867 100644 --- a/vr_instrumentOp_impl.h +++ b/vr_instrumentOp_impl.h @@ -141,7 +141,11 @@ case Iop_MAddF32: #ifndef IGNOREFMA - res.containFloatModOp=vr_replaceFMA (sb, stmt, expr, bcNameWithCC(madd32F), VR_OP_MADD, VR_PREC_FLT, countOnly); + if(vr.unfused){ + res.containFloatModOp=vr_replaceFMA (sb, stmt, expr, bcNameWithCCUnfused(madd32F), VR_OP_MADD, VR_PREC_FLT, countOnly); + }else{ + res.containFloatModOp=vr_replaceFMA (sb, stmt, expr, bcNameWithCC(madd32F), VR_OP_MADD, VR_PREC_FLT, countOnly); + } break; #else vr_countOp (sb, VR_OP_MADD, VR_PREC_FLT, VR_VEC_UNK,False); @@ -151,7 +155,11 @@ #endif case Iop_MSubF32: #ifndef IGNOREFMA - res.containFloatModOp=vr_replaceFMA (sb, stmt, expr, bcNameWithCC(msub32F), VR_OP_MSUB, VR_PREC_FLT, countOnly); + if(vr.unfused){ + res.containFloatModOp=vr_replaceFMA (sb, stmt, expr, bcNameWithCCUnfused(msub32F), VR_OP_MSUB, VR_PREC_FLT, countOnly); + }else{ + res.containFloatModOp=vr_replaceFMA (sb, stmt, expr, bcNameWithCC(msub32F), VR_OP_MSUB, VR_PREC_FLT, countOnly); + } break; #else res.containFloatModOp=False; @@ -161,7 +169,11 @@ #endif case Iop_MAddF64: #ifndef IGNOREFMA - res.containFloatModOp=vr_replaceFMA (sb, stmt, expr, bcNameConvWithCC(madd64F), VR_OP_MADD, VR_PREC_DBL, countOnly); + if(vr.unfused){ + res.containFloatModOp=vr_replaceFMA (sb, stmt, expr, bcNameConvWithCCUnfused(madd64F), VR_OP_MADD, VR_PREC_DBL, countOnly); + }else{ + res.containFloatModOp=vr_replaceFMA (sb, stmt, expr, bcNameConvWithCC(madd64F), VR_OP_MADD, VR_PREC_DBL, countOnly); + } break; #else res.containFloatModOp=False; @@ -171,7 +183,11 @@ #endif case Iop_MSubF64: #ifndef IGNOREFMA - res.containFloatModOp= vr_replaceFMA (sb, stmt, expr, bcNameConvWithCC(msub64F), VR_OP_MSUB, VR_PREC_DBL, countOnly); + if(vr.unfused){ + res.containFloatModOp= vr_replaceFMA (sb, stmt, expr, bcNameConvWithCCUnfused(msub64F), VR_OP_MSUB, VR_PREC_DBL, countOnly); + }else{ + res.containFloatModOp= vr_replaceFMA (sb, stmt, expr, bcNameConvWithCC(msub64F), VR_OP_MSUB, VR_PREC_DBL, countOnly); + } break; #else res.containFloatModOp=False; diff --git a/vr_instrumentOp_impl_generated_all_backends.h b/vr_instrumentOp_impl_generated_all_backends.h index 89090e3..b0d0076 100644 --- a/vr_instrumentOp_impl_generated_all_backends.h +++ b/vr_instrumentOp_impl_generated_all_backends.h @@ -5,45 +5,61 @@ if(vr.backend==vr_verrou && checkCancellation&& ! vr.checkFloatMax){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_soft"#OP, vr_verrou_soft##OP #define bcNameWithCC(OP) "vr_verroucheckcancellation_soft"#OP, vr_verroucheckcancellation_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verroucheckcancellation_soft"#OP, vr_unfused_verroucheckcancellation_soft##OP #define bcNameConv(OP) "vr_verrou_soft"#OP, vr_verrou_soft##OP #define bcNameConvWithCC(OP) "vr_verroucheckcancellation_soft"#OP, vr_verroucheckcancellation_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verroucheckcancellation_soft"#OP, vr_unfused_verroucheckcancellation_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }else{//vr.float_conv #define bcName(OP) "vr_verrou_soft"#OP, vr_verrou_soft##OP #define bcNameWithCC(OP) "vr_verroucheckcancellation_soft"#OP, vr_verroucheckcancellation_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verroucheckcancellation_soft"#OP, vr_unfused_verroucheckcancellation_soft##OP #define bcNameConv(OP) "vr_conv_verrou_soft"#OP, vr_conv_verrou_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verroucheckcancellation_soft"#OP, vr_conv_verroucheckcancellation_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verroucheckcancellation_soft"#OP, vr_unfused_conv_verroucheckcancellation_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }//end float_conv }else{//hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou"#OP, vr_verrou##OP #define bcNameWithCC(OP) "vr_verroucheckcancellation"#OP, vr_verroucheckcancellation##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verroucheckcancellation"#OP, vr_unfused_verroucheckcancellation##OP #define bcNameConv(OP) "vr_verrou"#OP, vr_verrou##OP #define bcNameConvWithCC(OP) "vr_verroucheckcancellation"#OP, vr_verroucheckcancellation##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verroucheckcancellation"#OP, vr_unfused_verroucheckcancellation##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused }else{//vr.float_conv #define bcName(OP) "vr_verrou"#OP, vr_verrou##OP #define bcNameWithCC(OP) "vr_verroucheckcancellation"#OP, vr_verroucheckcancellation##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verroucheckcancellation"#OP, vr_unfused_verroucheckcancellation##OP #define bcNameConv(OP) "vr_conv_verrou"#OP, vr_conv_verrou##OP #define bcNameConvWithCC(OP) "vr_conv_verroucheckcancellation"#OP, vr_conv_verroucheckcancellation##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verroucheckcancellation"#OP, vr_unfused_conv_verroucheckcancellation##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }//end float_conv }//end vr.instrument_soft_used) } @@ -52,23 +68,31 @@ if(vr.backend==vr_verrou && ! checkCancellation&& vr.checkFloatMax){ if(vr.instrument_soft_used){ #define bcName(OP) "vr_verroucheck_float_max_soft"#OP, vr_verroucheck_float_max_soft##OP #define bcNameWithCC(OP) "vr_verroucheck_float_max_soft"#OP, vr_verroucheck_float_max_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verroucheck_float_max_soft"#OP, vr_unfused_verroucheck_float_max_soft##OP #define bcNameConv(OP) "vr_verroucheck_float_max_soft"#OP, vr_verroucheck_float_max_soft##OP #define bcNameConvWithCC(OP) "vr_verroucheck_float_max_soft"#OP, vr_verroucheck_float_max_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verroucheck_float_max_soft"#OP, vr_unfused_verroucheck_float_max_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }else{//hard #define bcName(OP) "vr_verroucheck_float_max"#OP, vr_verroucheck_float_max##OP #define bcNameWithCC(OP) "vr_verroucheck_float_max"#OP, vr_verroucheck_float_max##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verroucheck_float_max"#OP, vr_unfused_verroucheck_float_max##OP #define bcNameConv(OP) "vr_verroucheck_float_max"#OP, vr_verroucheck_float_max##OP #define bcNameConvWithCC(OP) "vr_verroucheck_float_max"#OP, vr_verroucheck_float_max##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verroucheck_float_max"#OP, vr_unfused_verroucheck_float_max##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused }//end vr.instrument_soft_used) } @@ -77,45 +101,61 @@ if(vr.backend==vr_checkdenorm && ! checkCancellation){ if(!vr.float_conv){ #define bcName(OP) "vr_checkdenorm_soft"#OP, vr_checkdenorm_soft##OP #define bcNameWithCC(OP) "vr_checkdenorm_soft"#OP, vr_checkdenorm_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_checkdenorm_soft"#OP, vr_unfused_checkdenorm_soft##OP #define bcNameConv(OP) "vr_checkdenorm_soft"#OP, vr_checkdenorm_soft##OP #define bcNameConvWithCC(OP) "vr_checkdenorm_soft"#OP, vr_checkdenorm_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_checkdenorm_soft"#OP, vr_unfused_checkdenorm_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }else{//vr.float_conv #define bcName(OP) "vr_checkdenorm_soft"#OP, vr_checkdenorm_soft##OP #define bcNameWithCC(OP) "vr_checkdenorm_soft"#OP, vr_checkdenorm_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_checkdenorm_soft"#OP, vr_unfused_checkdenorm_soft##OP #define bcNameConv(OP) "vr_conv_checkdenorm_soft"#OP, vr_conv_checkdenorm_soft##OP #define bcNameConvWithCC(OP) "vr_conv_checkdenorm_soft"#OP, vr_conv_checkdenorm_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_checkdenorm_soft"#OP, vr_unfused_conv_checkdenorm_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }//end float_conv }else{//hard if(!vr.float_conv){ #define bcName(OP) "vr_checkdenorm"#OP, vr_checkdenorm##OP #define bcNameWithCC(OP) "vr_checkdenorm"#OP, vr_checkdenorm##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_checkdenorm"#OP, vr_unfused_checkdenorm##OP #define bcNameConv(OP) "vr_checkdenorm"#OP, vr_checkdenorm##OP #define bcNameConvWithCC(OP) "vr_checkdenorm"#OP, vr_checkdenorm##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_checkdenorm"#OP, vr_unfused_checkdenorm##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused }else{//vr.float_conv #define bcName(OP) "vr_checkdenorm"#OP, vr_checkdenorm##OP #define bcNameWithCC(OP) "vr_checkdenorm"#OP, vr_checkdenorm##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_checkdenorm"#OP, vr_unfused_checkdenorm##OP #define bcNameConv(OP) "vr_conv_checkdenorm"#OP, vr_conv_checkdenorm##OP #define bcNameConvWithCC(OP) "vr_conv_checkdenorm"#OP, vr_conv_checkdenorm##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_checkdenorm"#OP, vr_unfused_conv_checkdenorm##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }//end float_conv }//end vr.instrument_soft_used) } @@ -125,45 +165,61 @@ if(vr.backend==vr_checkdenorm && checkCancellation){ if(!vr.float_conv){ #define bcName(OP) "vr_checkdenorm_soft"#OP, vr_checkdenorm_soft##OP #define bcNameWithCC(OP) "vr_checkdenormcheckcancellation_soft"#OP, vr_checkdenormcheckcancellation_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_checkdenormcheckcancellation_soft"#OP, vr_unfused_checkdenormcheckcancellation_soft##OP #define bcNameConv(OP) "vr_checkdenorm_soft"#OP, vr_checkdenorm_soft##OP #define bcNameConvWithCC(OP) "vr_checkdenormcheckcancellation_soft"#OP, vr_checkdenormcheckcancellation_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_checkdenormcheckcancellation_soft"#OP, vr_unfused_checkdenormcheckcancellation_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }else{//vr.float_conv #define bcName(OP) "vr_checkdenorm_soft"#OP, vr_checkdenorm_soft##OP #define bcNameWithCC(OP) "vr_checkdenormcheckcancellation_soft"#OP, vr_checkdenormcheckcancellation_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_checkdenormcheckcancellation_soft"#OP, vr_unfused_checkdenormcheckcancellation_soft##OP #define bcNameConv(OP) "vr_conv_checkdenorm_soft"#OP, vr_conv_checkdenorm_soft##OP #define bcNameConvWithCC(OP) "vr_conv_checkdenormcheckcancellation_soft"#OP, vr_conv_checkdenormcheckcancellation_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_checkdenormcheckcancellation_soft"#OP, vr_unfused_conv_checkdenormcheckcancellation_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }//end float_conv }else{//hard if(!vr.float_conv){ #define bcName(OP) "vr_checkdenorm"#OP, vr_checkdenorm##OP #define bcNameWithCC(OP) "vr_checkdenormcheckcancellation"#OP, vr_checkdenormcheckcancellation##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_checkdenormcheckcancellation"#OP, vr_unfused_checkdenormcheckcancellation##OP #define bcNameConv(OP) "vr_checkdenorm"#OP, vr_checkdenorm##OP #define bcNameConvWithCC(OP) "vr_checkdenormcheckcancellation"#OP, vr_checkdenormcheckcancellation##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_checkdenormcheckcancellation"#OP, vr_unfused_checkdenormcheckcancellation##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused }else{//vr.float_conv #define bcName(OP) "vr_checkdenorm"#OP, vr_checkdenorm##OP #define bcNameWithCC(OP) "vr_checkdenormcheckcancellation"#OP, vr_checkdenormcheckcancellation##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_checkdenormcheckcancellation"#OP, vr_unfused_checkdenormcheckcancellation##OP #define bcNameConv(OP) "vr_conv_checkdenorm"#OP, vr_conv_checkdenorm##OP #define bcNameConvWithCC(OP) "vr_conv_checkdenormcheckcancellation"#OP, vr_conv_checkdenormcheckcancellation##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_checkdenormcheckcancellation"#OP, vr_unfused_conv_checkdenormcheckcancellation##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }//end float_conv }//end vr.instrument_soft_used) } @@ -175,45 +231,61 @@ if(vr.backend==vr_mcaquad && ! checkCancellation){ if(!vr.float_conv){ #define bcName(OP) "vr_mcaquad_soft"#OP, vr_mcaquad_soft##OP #define bcNameWithCC(OP) "vr_mcaquad_soft"#OP, vr_mcaquad_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_mcaquad_soft"#OP, vr_unfused_mcaquad_soft##OP #define bcNameConv(OP) "vr_mcaquad_soft"#OP, vr_mcaquad_soft##OP #define bcNameConvWithCC(OP) "vr_mcaquad_soft"#OP, vr_mcaquad_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_mcaquad_soft"#OP, vr_unfused_mcaquad_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }else{//vr.float_conv #define bcName(OP) "vr_mcaquad_soft"#OP, vr_mcaquad_soft##OP #define bcNameWithCC(OP) "vr_mcaquad_soft"#OP, vr_mcaquad_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_mcaquad_soft"#OP, vr_unfused_mcaquad_soft##OP #define bcNameConv(OP) "vr_conv_mcaquad_soft"#OP, vr_conv_mcaquad_soft##OP #define bcNameConvWithCC(OP) "vr_conv_mcaquad_soft"#OP, vr_conv_mcaquad_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_mcaquad_soft"#OP, vr_unfused_conv_mcaquad_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }//end float_conv }else{//hard if(!vr.float_conv){ #define bcName(OP) "vr_mcaquad"#OP, vr_mcaquad##OP #define bcNameWithCC(OP) "vr_mcaquad"#OP, vr_mcaquad##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_mcaquad"#OP, vr_unfused_mcaquad##OP #define bcNameConv(OP) "vr_mcaquad"#OP, vr_mcaquad##OP #define bcNameConvWithCC(OP) "vr_mcaquad"#OP, vr_mcaquad##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_mcaquad"#OP, vr_unfused_mcaquad##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused }else{//vr.float_conv #define bcName(OP) "vr_mcaquad"#OP, vr_mcaquad##OP #define bcNameWithCC(OP) "vr_mcaquad"#OP, vr_mcaquad##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_mcaquad"#OP, vr_unfused_mcaquad##OP #define bcNameConv(OP) "vr_conv_mcaquad"#OP, vr_conv_mcaquad##OP #define bcNameConvWithCC(OP) "vr_conv_mcaquad"#OP, vr_conv_mcaquad##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_mcaquad"#OP, vr_unfused_conv_mcaquad##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }//end float_conv }//end vr.instrument_soft_used) } @@ -223,45 +295,61 @@ if(vr.backend==vr_mcaquad && checkCancellation){ if(!vr.float_conv){ #define bcName(OP) "vr_mcaquad_soft"#OP, vr_mcaquad_soft##OP #define bcNameWithCC(OP) "vr_mcaquadcheckcancellation_soft"#OP, vr_mcaquadcheckcancellation_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_mcaquadcheckcancellation_soft"#OP, vr_unfused_mcaquadcheckcancellation_soft##OP #define bcNameConv(OP) "vr_mcaquad_soft"#OP, vr_mcaquad_soft##OP #define bcNameConvWithCC(OP) "vr_mcaquadcheckcancellation_soft"#OP, vr_mcaquadcheckcancellation_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_mcaquadcheckcancellation_soft"#OP, vr_unfused_mcaquadcheckcancellation_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }else{//vr.float_conv #define bcName(OP) "vr_mcaquad_soft"#OP, vr_mcaquad_soft##OP #define bcNameWithCC(OP) "vr_mcaquadcheckcancellation_soft"#OP, vr_mcaquadcheckcancellation_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_mcaquadcheckcancellation_soft"#OP, vr_unfused_mcaquadcheckcancellation_soft##OP #define bcNameConv(OP) "vr_conv_mcaquad_soft"#OP, vr_conv_mcaquad_soft##OP #define bcNameConvWithCC(OP) "vr_conv_mcaquadcheckcancellation_soft"#OP, vr_conv_mcaquadcheckcancellation_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_mcaquadcheckcancellation_soft"#OP, vr_unfused_conv_mcaquadcheckcancellation_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }//end float_conv }else{//hard if(!vr.float_conv){ #define bcName(OP) "vr_mcaquad"#OP, vr_mcaquad##OP #define bcNameWithCC(OP) "vr_mcaquadcheckcancellation"#OP, vr_mcaquadcheckcancellation##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_mcaquadcheckcancellation"#OP, vr_unfused_mcaquadcheckcancellation##OP #define bcNameConv(OP) "vr_mcaquad"#OP, vr_mcaquad##OP #define bcNameConvWithCC(OP) "vr_mcaquadcheckcancellation"#OP, vr_mcaquadcheckcancellation##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_mcaquadcheckcancellation"#OP, vr_unfused_mcaquadcheckcancellation##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused }else{//vr.float_conv #define bcName(OP) "vr_mcaquad"#OP, vr_mcaquad##OP #define bcNameWithCC(OP) "vr_mcaquadcheckcancellation"#OP, vr_mcaquadcheckcancellation##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_mcaquadcheckcancellation"#OP, vr_unfused_mcaquadcheckcancellation##OP #define bcNameConv(OP) "vr_conv_mcaquad"#OP, vr_conv_mcaquad##OP #define bcNameConvWithCC(OP) "vr_conv_mcaquadcheckcancellation"#OP, vr_conv_mcaquadcheckcancellation##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_mcaquadcheckcancellation"#OP, vr_unfused_conv_mcaquadcheckcancellation##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }//end float_conv }//end vr.instrument_soft_used) } diff --git a/vr_instrumentOp_impl_generated_verrou_specific.h b/vr_instrumentOp_impl_generated_verrou_specific.h index 9293219..e075bfa 100644 --- a/vr_instrumentOp_impl_generated_verrou_specific.h +++ b/vr_instrumentOp_impl_generated_verrou_specific.h @@ -5,45 +5,63 @@ if(vr.roundingMode==VR_NEAREST || vr.roundingMode==VR_NATIVE){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP #define bcNameWithCC(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_NEAREST_soft"#OP, vr_unfused_verrou_NEAREST_soft##OP #define bcNameConv(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP #define bcNameConvWithCC(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_NEAREST_soft"#OP, vr_unfused_verrou_NEAREST_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }else{//vr.float_conv #define bcName(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP #define bcNameWithCC(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_NEAREST_soft"#OP, vr_unfused_verrou_NEAREST_soft##OP #define bcNameConv(OP) "vr_conv_verrou_NEAREST_soft"#OP, vr_conv_verrou_NEAREST_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_NEAREST_soft"#OP, vr_conv_verrou_NEAREST_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_NEAREST_soft"#OP, vr_unfused_conv_verrou_NEAREST_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP #define bcNameWithCC(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_NEAREST"#OP, vr_unfused_verrou_NEAREST##OP #define bcNameConv(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP #define bcNameConvWithCC(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_NEAREST"#OP, vr_unfused_verrou_NEAREST##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP #define bcNameWithCC(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_NEAREST"#OP, vr_unfused_verrou_NEAREST##OP #define bcNameConv(OP) "vr_conv_verrou_NEAREST"#OP, vr_conv_verrou_NEAREST##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_NEAREST"#OP, vr_conv_verrou_NEAREST##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_NEAREST"#OP, vr_unfused_conv_verrou_NEAREST##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -52,45 +70,65 @@ if(vr.roundingMode==VR_RANDOM){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_RANDOM_soft"#OP, vr_verrou_RANDOM_soft##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_soft"#OP, vr_verrou_RANDOM_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_soft"#OP, vr_unfused_verrou_RANDOM_soft##OP #define bcNameConv(OP) "vr_verrou_RANDOM_soft"#OP, vr_verrou_RANDOM_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_RANDOM_soft"#OP, vr_verrou_RANDOM_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_soft"#OP, vr_unfused_verrou_RANDOM_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_RANDOM_soft"#OP, vr_verrou_RANDOM_soft##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_soft"#OP, vr_verrou_RANDOM_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_soft"#OP, vr_unfused_verrou_RANDOM_soft##OP #define bcNameConv(OP) "vr_conv_verrou_RANDOM_soft"#OP, vr_conv_verrou_RANDOM_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_RANDOM_soft"#OP, vr_conv_verrou_RANDOM_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_RANDOM_soft"#OP, vr_unfused_conv_verrou_RANDOM_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_RANDOM"#OP, vr_verrou_RANDOM##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM"#OP, vr_verrou_RANDOM##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM"#OP, vr_unfused_verrou_RANDOM##OP #define bcNameConv(OP) "vr_verrou_RANDOM"#OP, vr_verrou_RANDOM##OP #define bcNameConvWithCC(OP) "vr_verrou_RANDOM"#OP, vr_verrou_RANDOM##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_RANDOM"#OP, vr_unfused_verrou_RANDOM##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_RANDOM"#OP, vr_verrou_RANDOM##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM"#OP, vr_verrou_RANDOM##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM"#OP, vr_unfused_verrou_RANDOM##OP #define bcNameConv(OP) "vr_conv_verrou_RANDOM"#OP, vr_conv_verrou_RANDOM##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_RANDOM"#OP, vr_conv_verrou_RANDOM##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_RANDOM"#OP, vr_unfused_conv_verrou_RANDOM##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -99,45 +137,65 @@ if(vr.roundingMode==VR_AVERAGE){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_AVERAGE_soft"#OP, vr_verrou_AVERAGE_soft##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_soft"#OP, vr_verrou_AVERAGE_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_soft"#OP, vr_unfused_verrou_AVERAGE_soft##OP #define bcNameConv(OP) "vr_verrou_AVERAGE_soft"#OP, vr_verrou_AVERAGE_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_AVERAGE_soft"#OP, vr_verrou_AVERAGE_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_soft"#OP, vr_unfused_verrou_AVERAGE_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_AVERAGE_soft"#OP, vr_verrou_AVERAGE_soft##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_soft"#OP, vr_verrou_AVERAGE_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_soft"#OP, vr_unfused_verrou_AVERAGE_soft##OP #define bcNameConv(OP) "vr_conv_verrou_AVERAGE_soft"#OP, vr_conv_verrou_AVERAGE_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_AVERAGE_soft"#OP, vr_conv_verrou_AVERAGE_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_AVERAGE_soft"#OP, vr_unfused_conv_verrou_AVERAGE_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_AVERAGE"#OP, vr_verrou_AVERAGE##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE"#OP, vr_verrou_AVERAGE##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE"#OP, vr_unfused_verrou_AVERAGE##OP #define bcNameConv(OP) "vr_verrou_AVERAGE"#OP, vr_verrou_AVERAGE##OP #define bcNameConvWithCC(OP) "vr_verrou_AVERAGE"#OP, vr_verrou_AVERAGE##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE"#OP, vr_unfused_verrou_AVERAGE##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_AVERAGE"#OP, vr_verrou_AVERAGE##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE"#OP, vr_verrou_AVERAGE##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE"#OP, vr_unfused_verrou_AVERAGE##OP #define bcNameConv(OP) "vr_conv_verrou_AVERAGE"#OP, vr_conv_verrou_AVERAGE##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_AVERAGE"#OP, vr_conv_verrou_AVERAGE##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_AVERAGE"#OP, vr_unfused_conv_verrou_AVERAGE##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -146,45 +204,65 @@ if(vr.roundingMode==VR_RANDOM_DET){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_RANDOM_DET_soft"#OP, vr_verrou_RANDOM_DET_soft##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_DET_soft"#OP, vr_verrou_RANDOM_DET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_DET_soft"#OP, vr_unfused_verrou_RANDOM_DET_soft##OP #define bcNameConv(OP) "vr_verrou_RANDOM_DET_soft"#OP, vr_verrou_RANDOM_DET_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_RANDOM_DET_soft"#OP, vr_verrou_RANDOM_DET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_DET_soft"#OP, vr_unfused_verrou_RANDOM_DET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_RANDOM_DET_soft"#OP, vr_verrou_RANDOM_DET_soft##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_DET_soft"#OP, vr_verrou_RANDOM_DET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_DET_soft"#OP, vr_unfused_verrou_RANDOM_DET_soft##OP #define bcNameConv(OP) "vr_conv_verrou_RANDOM_DET_soft"#OP, vr_conv_verrou_RANDOM_DET_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_RANDOM_DET_soft"#OP, vr_conv_verrou_RANDOM_DET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_RANDOM_DET_soft"#OP, vr_unfused_conv_verrou_RANDOM_DET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_RANDOM_DET"#OP, vr_verrou_RANDOM_DET##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_DET"#OP, vr_verrou_RANDOM_DET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_DET"#OP, vr_unfused_verrou_RANDOM_DET##OP #define bcNameConv(OP) "vr_verrou_RANDOM_DET"#OP, vr_verrou_RANDOM_DET##OP #define bcNameConvWithCC(OP) "vr_verrou_RANDOM_DET"#OP, vr_verrou_RANDOM_DET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_DET"#OP, vr_unfused_verrou_RANDOM_DET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_RANDOM_DET"#OP, vr_verrou_RANDOM_DET##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_DET"#OP, vr_verrou_RANDOM_DET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_DET"#OP, vr_unfused_verrou_RANDOM_DET##OP #define bcNameConv(OP) "vr_conv_verrou_RANDOM_DET"#OP, vr_conv_verrou_RANDOM_DET##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_RANDOM_DET"#OP, vr_conv_verrou_RANDOM_DET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_RANDOM_DET"#OP, vr_unfused_conv_verrou_RANDOM_DET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -193,45 +271,65 @@ if(vr.roundingMode==VR_AVERAGE_DET){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_AVERAGE_DET_soft"#OP, vr_verrou_AVERAGE_DET_soft##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_DET_soft"#OP, vr_verrou_AVERAGE_DET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_DET_soft"#OP, vr_unfused_verrou_AVERAGE_DET_soft##OP #define bcNameConv(OP) "vr_verrou_AVERAGE_DET_soft"#OP, vr_verrou_AVERAGE_DET_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_AVERAGE_DET_soft"#OP, vr_verrou_AVERAGE_DET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_DET_soft"#OP, vr_unfused_verrou_AVERAGE_DET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_AVERAGE_DET_soft"#OP, vr_verrou_AVERAGE_DET_soft##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_DET_soft"#OP, vr_verrou_AVERAGE_DET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_DET_soft"#OP, vr_unfused_verrou_AVERAGE_DET_soft##OP #define bcNameConv(OP) "vr_conv_verrou_AVERAGE_DET_soft"#OP, vr_conv_verrou_AVERAGE_DET_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_AVERAGE_DET_soft"#OP, vr_conv_verrou_AVERAGE_DET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_AVERAGE_DET_soft"#OP, vr_unfused_conv_verrou_AVERAGE_DET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_AVERAGE_DET"#OP, vr_verrou_AVERAGE_DET##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_DET"#OP, vr_verrou_AVERAGE_DET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_DET"#OP, vr_unfused_verrou_AVERAGE_DET##OP #define bcNameConv(OP) "vr_verrou_AVERAGE_DET"#OP, vr_verrou_AVERAGE_DET##OP #define bcNameConvWithCC(OP) "vr_verrou_AVERAGE_DET"#OP, vr_verrou_AVERAGE_DET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_DET"#OP, vr_unfused_verrou_AVERAGE_DET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_AVERAGE_DET"#OP, vr_verrou_AVERAGE_DET##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_DET"#OP, vr_verrou_AVERAGE_DET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_DET"#OP, vr_unfused_verrou_AVERAGE_DET##OP #define bcNameConv(OP) "vr_conv_verrou_AVERAGE_DET"#OP, vr_conv_verrou_AVERAGE_DET##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_AVERAGE_DET"#OP, vr_conv_verrou_AVERAGE_DET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_AVERAGE_DET"#OP, vr_unfused_conv_verrou_AVERAGE_DET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -240,45 +338,65 @@ if(vr.roundingMode==VR_RANDOM_COMDET){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_RANDOM_COMDET_soft"#OP, vr_verrou_RANDOM_COMDET_soft##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_COMDET_soft"#OP, vr_verrou_RANDOM_COMDET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_COMDET_soft"#OP, vr_unfused_verrou_RANDOM_COMDET_soft##OP #define bcNameConv(OP) "vr_verrou_RANDOM_COMDET_soft"#OP, vr_verrou_RANDOM_COMDET_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_RANDOM_COMDET_soft"#OP, vr_verrou_RANDOM_COMDET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_COMDET_soft"#OP, vr_unfused_verrou_RANDOM_COMDET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_RANDOM_COMDET_soft"#OP, vr_verrou_RANDOM_COMDET_soft##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_COMDET_soft"#OP, vr_verrou_RANDOM_COMDET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_COMDET_soft"#OP, vr_unfused_verrou_RANDOM_COMDET_soft##OP #define bcNameConv(OP) "vr_conv_verrou_RANDOM_COMDET_soft"#OP, vr_conv_verrou_RANDOM_COMDET_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_RANDOM_COMDET_soft"#OP, vr_conv_verrou_RANDOM_COMDET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_RANDOM_COMDET_soft"#OP, vr_unfused_conv_verrou_RANDOM_COMDET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_RANDOM_COMDET"#OP, vr_verrou_RANDOM_COMDET##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_COMDET"#OP, vr_verrou_RANDOM_COMDET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_COMDET"#OP, vr_unfused_verrou_RANDOM_COMDET##OP #define bcNameConv(OP) "vr_verrou_RANDOM_COMDET"#OP, vr_verrou_RANDOM_COMDET##OP #define bcNameConvWithCC(OP) "vr_verrou_RANDOM_COMDET"#OP, vr_verrou_RANDOM_COMDET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_COMDET"#OP, vr_unfused_verrou_RANDOM_COMDET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_RANDOM_COMDET"#OP, vr_verrou_RANDOM_COMDET##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_COMDET"#OP, vr_verrou_RANDOM_COMDET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_COMDET"#OP, vr_unfused_verrou_RANDOM_COMDET##OP #define bcNameConv(OP) "vr_conv_verrou_RANDOM_COMDET"#OP, vr_conv_verrou_RANDOM_COMDET##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_RANDOM_COMDET"#OP, vr_conv_verrou_RANDOM_COMDET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_RANDOM_COMDET"#OP, vr_unfused_conv_verrou_RANDOM_COMDET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -287,45 +405,65 @@ if(vr.roundingMode==VR_AVERAGE_COMDET){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_AVERAGE_COMDET_soft"#OP, vr_verrou_AVERAGE_COMDET_soft##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_COMDET_soft"#OP, vr_verrou_AVERAGE_COMDET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_COMDET_soft"#OP, vr_unfused_verrou_AVERAGE_COMDET_soft##OP #define bcNameConv(OP) "vr_verrou_AVERAGE_COMDET_soft"#OP, vr_verrou_AVERAGE_COMDET_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_AVERAGE_COMDET_soft"#OP, vr_verrou_AVERAGE_COMDET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_COMDET_soft"#OP, vr_unfused_verrou_AVERAGE_COMDET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_AVERAGE_COMDET_soft"#OP, vr_verrou_AVERAGE_COMDET_soft##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_COMDET_soft"#OP, vr_verrou_AVERAGE_COMDET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_COMDET_soft"#OP, vr_unfused_verrou_AVERAGE_COMDET_soft##OP #define bcNameConv(OP) "vr_conv_verrou_AVERAGE_COMDET_soft"#OP, vr_conv_verrou_AVERAGE_COMDET_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_AVERAGE_COMDET_soft"#OP, vr_conv_verrou_AVERAGE_COMDET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_AVERAGE_COMDET_soft"#OP, vr_unfused_conv_verrou_AVERAGE_COMDET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_AVERAGE_COMDET"#OP, vr_verrou_AVERAGE_COMDET##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_COMDET"#OP, vr_verrou_AVERAGE_COMDET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_COMDET"#OP, vr_unfused_verrou_AVERAGE_COMDET##OP #define bcNameConv(OP) "vr_verrou_AVERAGE_COMDET"#OP, vr_verrou_AVERAGE_COMDET##OP #define bcNameConvWithCC(OP) "vr_verrou_AVERAGE_COMDET"#OP, vr_verrou_AVERAGE_COMDET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_COMDET"#OP, vr_unfused_verrou_AVERAGE_COMDET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_AVERAGE_COMDET"#OP, vr_verrou_AVERAGE_COMDET##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_COMDET"#OP, vr_verrou_AVERAGE_COMDET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_COMDET"#OP, vr_unfused_verrou_AVERAGE_COMDET##OP #define bcNameConv(OP) "vr_conv_verrou_AVERAGE_COMDET"#OP, vr_conv_verrou_AVERAGE_COMDET##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_AVERAGE_COMDET"#OP, vr_conv_verrou_AVERAGE_COMDET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_AVERAGE_COMDET"#OP, vr_unfused_conv_verrou_AVERAGE_COMDET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -334,45 +472,65 @@ if(vr.roundingMode==VR_RANDOM_SCOMDET){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_RANDOM_SCOMDET_soft"#OP, vr_verrou_RANDOM_SCOMDET_soft##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_SCOMDET_soft"#OP, vr_verrou_RANDOM_SCOMDET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_SCOMDET_soft"#OP, vr_unfused_verrou_RANDOM_SCOMDET_soft##OP #define bcNameConv(OP) "vr_verrou_RANDOM_SCOMDET_soft"#OP, vr_verrou_RANDOM_SCOMDET_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_RANDOM_SCOMDET_soft"#OP, vr_verrou_RANDOM_SCOMDET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_SCOMDET_soft"#OP, vr_unfused_verrou_RANDOM_SCOMDET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_RANDOM_SCOMDET_soft"#OP, vr_verrou_RANDOM_SCOMDET_soft##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_SCOMDET_soft"#OP, vr_verrou_RANDOM_SCOMDET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_SCOMDET_soft"#OP, vr_unfused_verrou_RANDOM_SCOMDET_soft##OP #define bcNameConv(OP) "vr_conv_verrou_RANDOM_SCOMDET_soft"#OP, vr_conv_verrou_RANDOM_SCOMDET_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_RANDOM_SCOMDET_soft"#OP, vr_conv_verrou_RANDOM_SCOMDET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_RANDOM_SCOMDET_soft"#OP, vr_unfused_conv_verrou_RANDOM_SCOMDET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_RANDOM_SCOMDET"#OP, vr_verrou_RANDOM_SCOMDET##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_SCOMDET"#OP, vr_verrou_RANDOM_SCOMDET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_SCOMDET"#OP, vr_unfused_verrou_RANDOM_SCOMDET##OP #define bcNameConv(OP) "vr_verrou_RANDOM_SCOMDET"#OP, vr_verrou_RANDOM_SCOMDET##OP #define bcNameConvWithCC(OP) "vr_verrou_RANDOM_SCOMDET"#OP, vr_verrou_RANDOM_SCOMDET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_SCOMDET"#OP, vr_unfused_verrou_RANDOM_SCOMDET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_RANDOM_SCOMDET"#OP, vr_verrou_RANDOM_SCOMDET##OP #define bcNameWithCC(OP) "vr_verrou_RANDOM_SCOMDET"#OP, vr_verrou_RANDOM_SCOMDET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_RANDOM_SCOMDET"#OP, vr_unfused_verrou_RANDOM_SCOMDET##OP #define bcNameConv(OP) "vr_conv_verrou_RANDOM_SCOMDET"#OP, vr_conv_verrou_RANDOM_SCOMDET##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_RANDOM_SCOMDET"#OP, vr_conv_verrou_RANDOM_SCOMDET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_RANDOM_SCOMDET"#OP, vr_unfused_conv_verrou_RANDOM_SCOMDET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -381,45 +539,65 @@ if(vr.roundingMode==VR_AVERAGE_SCOMDET){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_AVERAGE_SCOMDET_soft"#OP, vr_verrou_AVERAGE_SCOMDET_soft##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_SCOMDET_soft"#OP, vr_verrou_AVERAGE_SCOMDET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_SCOMDET_soft"#OP, vr_unfused_verrou_AVERAGE_SCOMDET_soft##OP #define bcNameConv(OP) "vr_verrou_AVERAGE_SCOMDET_soft"#OP, vr_verrou_AVERAGE_SCOMDET_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_AVERAGE_SCOMDET_soft"#OP, vr_verrou_AVERAGE_SCOMDET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_SCOMDET_soft"#OP, vr_unfused_verrou_AVERAGE_SCOMDET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_AVERAGE_SCOMDET_soft"#OP, vr_verrou_AVERAGE_SCOMDET_soft##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_SCOMDET_soft"#OP, vr_verrou_AVERAGE_SCOMDET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_SCOMDET_soft"#OP, vr_unfused_verrou_AVERAGE_SCOMDET_soft##OP #define bcNameConv(OP) "vr_conv_verrou_AVERAGE_SCOMDET_soft"#OP, vr_conv_verrou_AVERAGE_SCOMDET_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_AVERAGE_SCOMDET_soft"#OP, vr_conv_verrou_AVERAGE_SCOMDET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_AVERAGE_SCOMDET_soft"#OP, vr_unfused_conv_verrou_AVERAGE_SCOMDET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_AVERAGE_SCOMDET"#OP, vr_verrou_AVERAGE_SCOMDET##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_SCOMDET"#OP, vr_verrou_AVERAGE_SCOMDET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_SCOMDET"#OP, vr_unfused_verrou_AVERAGE_SCOMDET##OP #define bcNameConv(OP) "vr_verrou_AVERAGE_SCOMDET"#OP, vr_verrou_AVERAGE_SCOMDET##OP #define bcNameConvWithCC(OP) "vr_verrou_AVERAGE_SCOMDET"#OP, vr_verrou_AVERAGE_SCOMDET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_SCOMDET"#OP, vr_unfused_verrou_AVERAGE_SCOMDET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_AVERAGE_SCOMDET"#OP, vr_verrou_AVERAGE_SCOMDET##OP #define bcNameWithCC(OP) "vr_verrou_AVERAGE_SCOMDET"#OP, vr_verrou_AVERAGE_SCOMDET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AVERAGE_SCOMDET"#OP, vr_unfused_verrou_AVERAGE_SCOMDET##OP #define bcNameConv(OP) "vr_conv_verrou_AVERAGE_SCOMDET"#OP, vr_conv_verrou_AVERAGE_SCOMDET##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_AVERAGE_SCOMDET"#OP, vr_conv_verrou_AVERAGE_SCOMDET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_AVERAGE_SCOMDET"#OP, vr_unfused_conv_verrou_AVERAGE_SCOMDET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -428,45 +606,65 @@ if(vr.roundingMode==VR_SR_MONOTONIC){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_SR_MONOTONIC_soft"#OP, vr_verrou_SR_MONOTONIC_soft##OP #define bcNameWithCC(OP) "vr_verrou_SR_MONOTONIC_soft"#OP, vr_verrou_SR_MONOTONIC_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_SR_MONOTONIC_soft"#OP, vr_unfused_verrou_SR_MONOTONIC_soft##OP #define bcNameConv(OP) "vr_verrou_SR_MONOTONIC_soft"#OP, vr_verrou_SR_MONOTONIC_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_SR_MONOTONIC_soft"#OP, vr_verrou_SR_MONOTONIC_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_SR_MONOTONIC_soft"#OP, vr_unfused_verrou_SR_MONOTONIC_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_SR_MONOTONIC_soft"#OP, vr_verrou_SR_MONOTONIC_soft##OP #define bcNameWithCC(OP) "vr_verrou_SR_MONOTONIC_soft"#OP, vr_verrou_SR_MONOTONIC_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_SR_MONOTONIC_soft"#OP, vr_unfused_verrou_SR_MONOTONIC_soft##OP #define bcNameConv(OP) "vr_conv_verrou_SR_MONOTONIC_soft"#OP, vr_conv_verrou_SR_MONOTONIC_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_SR_MONOTONIC_soft"#OP, vr_conv_verrou_SR_MONOTONIC_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_SR_MONOTONIC_soft"#OP, vr_unfused_conv_verrou_SR_MONOTONIC_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_SR_MONOTONIC"#OP, vr_verrou_SR_MONOTONIC##OP #define bcNameWithCC(OP) "vr_verrou_SR_MONOTONIC"#OP, vr_verrou_SR_MONOTONIC##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_SR_MONOTONIC"#OP, vr_unfused_verrou_SR_MONOTONIC##OP #define bcNameConv(OP) "vr_verrou_SR_MONOTONIC"#OP, vr_verrou_SR_MONOTONIC##OP #define bcNameConvWithCC(OP) "vr_verrou_SR_MONOTONIC"#OP, vr_verrou_SR_MONOTONIC##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_SR_MONOTONIC"#OP, vr_unfused_verrou_SR_MONOTONIC##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_SR_MONOTONIC"#OP, vr_verrou_SR_MONOTONIC##OP #define bcNameWithCC(OP) "vr_verrou_SR_MONOTONIC"#OP, vr_verrou_SR_MONOTONIC##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_SR_MONOTONIC"#OP, vr_unfused_verrou_SR_MONOTONIC##OP #define bcNameConv(OP) "vr_conv_verrou_SR_MONOTONIC"#OP, vr_conv_verrou_SR_MONOTONIC##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_SR_MONOTONIC"#OP, vr_conv_verrou_SR_MONOTONIC##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_SR_MONOTONIC"#OP, vr_unfused_conv_verrou_SR_MONOTONIC##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -475,45 +673,65 @@ if(vr.roundingMode==VR_SR_SMONOTONIC){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_SR_SMONOTONIC_soft"#OP, vr_verrou_SR_SMONOTONIC_soft##OP #define bcNameWithCC(OP) "vr_verrou_SR_SMONOTONIC_soft"#OP, vr_verrou_SR_SMONOTONIC_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_SR_SMONOTONIC_soft"#OP, vr_unfused_verrou_SR_SMONOTONIC_soft##OP #define bcNameConv(OP) "vr_verrou_SR_SMONOTONIC_soft"#OP, vr_verrou_SR_SMONOTONIC_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_SR_SMONOTONIC_soft"#OP, vr_verrou_SR_SMONOTONIC_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_SR_SMONOTONIC_soft"#OP, vr_unfused_verrou_SR_SMONOTONIC_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_SR_SMONOTONIC_soft"#OP, vr_verrou_SR_SMONOTONIC_soft##OP #define bcNameWithCC(OP) "vr_verrou_SR_SMONOTONIC_soft"#OP, vr_verrou_SR_SMONOTONIC_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_SR_SMONOTONIC_soft"#OP, vr_unfused_verrou_SR_SMONOTONIC_soft##OP #define bcNameConv(OP) "vr_conv_verrou_SR_SMONOTONIC_soft"#OP, vr_conv_verrou_SR_SMONOTONIC_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_SR_SMONOTONIC_soft"#OP, vr_conv_verrou_SR_SMONOTONIC_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_SR_SMONOTONIC_soft"#OP, vr_unfused_conv_verrou_SR_SMONOTONIC_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_SR_SMONOTONIC"#OP, vr_verrou_SR_SMONOTONIC##OP #define bcNameWithCC(OP) "vr_verrou_SR_SMONOTONIC"#OP, vr_verrou_SR_SMONOTONIC##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_SR_SMONOTONIC"#OP, vr_unfused_verrou_SR_SMONOTONIC##OP #define bcNameConv(OP) "vr_verrou_SR_SMONOTONIC"#OP, vr_verrou_SR_SMONOTONIC##OP #define bcNameConvWithCC(OP) "vr_verrou_SR_SMONOTONIC"#OP, vr_verrou_SR_SMONOTONIC##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_SR_SMONOTONIC"#OP, vr_unfused_verrou_SR_SMONOTONIC##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_SR_SMONOTONIC"#OP, vr_verrou_SR_SMONOTONIC##OP #define bcNameWithCC(OP) "vr_verrou_SR_SMONOTONIC"#OP, vr_verrou_SR_SMONOTONIC##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_SR_SMONOTONIC"#OP, vr_unfused_verrou_SR_SMONOTONIC##OP #define bcNameConv(OP) "vr_conv_verrou_SR_SMONOTONIC"#OP, vr_conv_verrou_SR_SMONOTONIC##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_SR_SMONOTONIC"#OP, vr_conv_verrou_SR_SMONOTONIC##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_SR_SMONOTONIC"#OP, vr_unfused_conv_verrou_SR_SMONOTONIC##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -522,45 +740,65 @@ if(vr.roundingMode==VR_UPWARD){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_UPWARD_soft"#OP, vr_verrou_UPWARD_soft##OP #define bcNameWithCC(OP) "vr_verrou_UPWARD_soft"#OP, vr_verrou_UPWARD_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_UPWARD_soft"#OP, vr_unfused_verrou_UPWARD_soft##OP #define bcNameConv(OP) "vr_verrou_UPWARD_soft"#OP, vr_verrou_UPWARD_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_UPWARD_soft"#OP, vr_verrou_UPWARD_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_UPWARD_soft"#OP, vr_unfused_verrou_UPWARD_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_UPWARD_soft"#OP, vr_verrou_UPWARD_soft##OP #define bcNameWithCC(OP) "vr_verrou_UPWARD_soft"#OP, vr_verrou_UPWARD_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_UPWARD_soft"#OP, vr_unfused_verrou_UPWARD_soft##OP #define bcNameConv(OP) "vr_conv_verrou_UPWARD_soft"#OP, vr_conv_verrou_UPWARD_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_UPWARD_soft"#OP, vr_conv_verrou_UPWARD_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_UPWARD_soft"#OP, vr_unfused_conv_verrou_UPWARD_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_UPWARD"#OP, vr_verrou_UPWARD##OP #define bcNameWithCC(OP) "vr_verrou_UPWARD"#OP, vr_verrou_UPWARD##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_UPWARD"#OP, vr_unfused_verrou_UPWARD##OP #define bcNameConv(OP) "vr_verrou_UPWARD"#OP, vr_verrou_UPWARD##OP #define bcNameConvWithCC(OP) "vr_verrou_UPWARD"#OP, vr_verrou_UPWARD##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_UPWARD"#OP, vr_unfused_verrou_UPWARD##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_UPWARD"#OP, vr_verrou_UPWARD##OP #define bcNameWithCC(OP) "vr_verrou_UPWARD"#OP, vr_verrou_UPWARD##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_UPWARD"#OP, vr_unfused_verrou_UPWARD##OP #define bcNameConv(OP) "vr_conv_verrou_UPWARD"#OP, vr_conv_verrou_UPWARD##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_UPWARD"#OP, vr_conv_verrou_UPWARD##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_UPWARD"#OP, vr_unfused_conv_verrou_UPWARD##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -569,45 +807,65 @@ if(vr.roundingMode==VR_DOWNWARD){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_DOWNWARD_soft"#OP, vr_verrou_DOWNWARD_soft##OP #define bcNameWithCC(OP) "vr_verrou_DOWNWARD_soft"#OP, vr_verrou_DOWNWARD_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_DOWNWARD_soft"#OP, vr_unfused_verrou_DOWNWARD_soft##OP #define bcNameConv(OP) "vr_verrou_DOWNWARD_soft"#OP, vr_verrou_DOWNWARD_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_DOWNWARD_soft"#OP, vr_verrou_DOWNWARD_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_DOWNWARD_soft"#OP, vr_unfused_verrou_DOWNWARD_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_DOWNWARD_soft"#OP, vr_verrou_DOWNWARD_soft##OP #define bcNameWithCC(OP) "vr_verrou_DOWNWARD_soft"#OP, vr_verrou_DOWNWARD_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_DOWNWARD_soft"#OP, vr_unfused_verrou_DOWNWARD_soft##OP #define bcNameConv(OP) "vr_conv_verrou_DOWNWARD_soft"#OP, vr_conv_verrou_DOWNWARD_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_DOWNWARD_soft"#OP, vr_conv_verrou_DOWNWARD_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_DOWNWARD_soft"#OP, vr_unfused_conv_verrou_DOWNWARD_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_DOWNWARD"#OP, vr_verrou_DOWNWARD##OP #define bcNameWithCC(OP) "vr_verrou_DOWNWARD"#OP, vr_verrou_DOWNWARD##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_DOWNWARD"#OP, vr_unfused_verrou_DOWNWARD##OP #define bcNameConv(OP) "vr_verrou_DOWNWARD"#OP, vr_verrou_DOWNWARD##OP #define bcNameConvWithCC(OP) "vr_verrou_DOWNWARD"#OP, vr_verrou_DOWNWARD##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_DOWNWARD"#OP, vr_unfused_verrou_DOWNWARD##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_DOWNWARD"#OP, vr_verrou_DOWNWARD##OP #define bcNameWithCC(OP) "vr_verrou_DOWNWARD"#OP, vr_verrou_DOWNWARD##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_DOWNWARD"#OP, vr_unfused_verrou_DOWNWARD##OP #define bcNameConv(OP) "vr_conv_verrou_DOWNWARD"#OP, vr_conv_verrou_DOWNWARD##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_DOWNWARD"#OP, vr_conv_verrou_DOWNWARD##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_DOWNWARD"#OP, vr_unfused_conv_verrou_DOWNWARD##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -616,45 +874,65 @@ if(vr.roundingMode==VR_ZERO){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_ZERO_soft"#OP, vr_verrou_ZERO_soft##OP #define bcNameWithCC(OP) "vr_verrou_ZERO_soft"#OP, vr_verrou_ZERO_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_ZERO_soft"#OP, vr_unfused_verrou_ZERO_soft##OP #define bcNameConv(OP) "vr_verrou_ZERO_soft"#OP, vr_verrou_ZERO_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_ZERO_soft"#OP, vr_verrou_ZERO_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_ZERO_soft"#OP, vr_unfused_verrou_ZERO_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_ZERO_soft"#OP, vr_verrou_ZERO_soft##OP #define bcNameWithCC(OP) "vr_verrou_ZERO_soft"#OP, vr_verrou_ZERO_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_ZERO_soft"#OP, vr_unfused_verrou_ZERO_soft##OP #define bcNameConv(OP) "vr_conv_verrou_ZERO_soft"#OP, vr_conv_verrou_ZERO_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_ZERO_soft"#OP, vr_conv_verrou_ZERO_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_ZERO_soft"#OP, vr_unfused_conv_verrou_ZERO_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_ZERO"#OP, vr_verrou_ZERO##OP #define bcNameWithCC(OP) "vr_verrou_ZERO"#OP, vr_verrou_ZERO##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_ZERO"#OP, vr_unfused_verrou_ZERO##OP #define bcNameConv(OP) "vr_verrou_ZERO"#OP, vr_verrou_ZERO##OP #define bcNameConvWithCC(OP) "vr_verrou_ZERO"#OP, vr_verrou_ZERO##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_ZERO"#OP, vr_unfused_verrou_ZERO##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_ZERO"#OP, vr_verrou_ZERO##OP #define bcNameWithCC(OP) "vr_verrou_ZERO"#OP, vr_verrou_ZERO##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_ZERO"#OP, vr_unfused_verrou_ZERO##OP #define bcNameConv(OP) "vr_conv_verrou_ZERO"#OP, vr_conv_verrou_ZERO##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_ZERO"#OP, vr_conv_verrou_ZERO##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_ZERO"#OP, vr_unfused_conv_verrou_ZERO##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -663,45 +941,65 @@ if(vr.roundingMode==VR_AWAY_ZERO){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_AWAY_ZERO_soft"#OP, vr_verrou_AWAY_ZERO_soft##OP #define bcNameWithCC(OP) "vr_verrou_AWAY_ZERO_soft"#OP, vr_verrou_AWAY_ZERO_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AWAY_ZERO_soft"#OP, vr_unfused_verrou_AWAY_ZERO_soft##OP #define bcNameConv(OP) "vr_verrou_AWAY_ZERO_soft"#OP, vr_verrou_AWAY_ZERO_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_AWAY_ZERO_soft"#OP, vr_verrou_AWAY_ZERO_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_AWAY_ZERO_soft"#OP, vr_unfused_verrou_AWAY_ZERO_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_AWAY_ZERO_soft"#OP, vr_verrou_AWAY_ZERO_soft##OP #define bcNameWithCC(OP) "vr_verrou_AWAY_ZERO_soft"#OP, vr_verrou_AWAY_ZERO_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AWAY_ZERO_soft"#OP, vr_unfused_verrou_AWAY_ZERO_soft##OP #define bcNameConv(OP) "vr_conv_verrou_AWAY_ZERO_soft"#OP, vr_conv_verrou_AWAY_ZERO_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_AWAY_ZERO_soft"#OP, vr_conv_verrou_AWAY_ZERO_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_AWAY_ZERO_soft"#OP, vr_unfused_conv_verrou_AWAY_ZERO_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_AWAY_ZERO"#OP, vr_verrou_AWAY_ZERO##OP #define bcNameWithCC(OP) "vr_verrou_AWAY_ZERO"#OP, vr_verrou_AWAY_ZERO##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AWAY_ZERO"#OP, vr_unfused_verrou_AWAY_ZERO##OP #define bcNameConv(OP) "vr_verrou_AWAY_ZERO"#OP, vr_verrou_AWAY_ZERO##OP #define bcNameConvWithCC(OP) "vr_verrou_AWAY_ZERO"#OP, vr_verrou_AWAY_ZERO##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_AWAY_ZERO"#OP, vr_unfused_verrou_AWAY_ZERO##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_AWAY_ZERO"#OP, vr_verrou_AWAY_ZERO##OP #define bcNameWithCC(OP) "vr_verrou_AWAY_ZERO"#OP, vr_verrou_AWAY_ZERO##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_AWAY_ZERO"#OP, vr_unfused_verrou_AWAY_ZERO##OP #define bcNameConv(OP) "vr_conv_verrou_AWAY_ZERO"#OP, vr_conv_verrou_AWAY_ZERO##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_AWAY_ZERO"#OP, vr_conv_verrou_AWAY_ZERO##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_AWAY_ZERO"#OP, vr_unfused_conv_verrou_AWAY_ZERO##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -710,45 +1008,65 @@ if(vr.roundingMode==VR_FARTHEST){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_FARTHEST_soft"#OP, vr_verrou_FARTHEST_soft##OP #define bcNameWithCC(OP) "vr_verrou_FARTHEST_soft"#OP, vr_verrou_FARTHEST_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_FARTHEST_soft"#OP, vr_unfused_verrou_FARTHEST_soft##OP #define bcNameConv(OP) "vr_verrou_FARTHEST_soft"#OP, vr_verrou_FARTHEST_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_FARTHEST_soft"#OP, vr_verrou_FARTHEST_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_FARTHEST_soft"#OP, vr_unfused_verrou_FARTHEST_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_FARTHEST_soft"#OP, vr_verrou_FARTHEST_soft##OP #define bcNameWithCC(OP) "vr_verrou_FARTHEST_soft"#OP, vr_verrou_FARTHEST_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_FARTHEST_soft"#OP, vr_unfused_verrou_FARTHEST_soft##OP #define bcNameConv(OP) "vr_conv_verrou_FARTHEST_soft"#OP, vr_conv_verrou_FARTHEST_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_FARTHEST_soft"#OP, vr_conv_verrou_FARTHEST_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_FARTHEST_soft"#OP, vr_unfused_conv_verrou_FARTHEST_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_FARTHEST"#OP, vr_verrou_FARTHEST##OP #define bcNameWithCC(OP) "vr_verrou_FARTHEST"#OP, vr_verrou_FARTHEST##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_FARTHEST"#OP, vr_unfused_verrou_FARTHEST##OP #define bcNameConv(OP) "vr_verrou_FARTHEST"#OP, vr_verrou_FARTHEST##OP #define bcNameConvWithCC(OP) "vr_verrou_FARTHEST"#OP, vr_verrou_FARTHEST##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_FARTHEST"#OP, vr_unfused_verrou_FARTHEST##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_FARTHEST"#OP, vr_verrou_FARTHEST##OP #define bcNameWithCC(OP) "vr_verrou_FARTHEST"#OP, vr_verrou_FARTHEST##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_FARTHEST"#OP, vr_unfused_verrou_FARTHEST##OP #define bcNameConv(OP) "vr_conv_verrou_FARTHEST"#OP, vr_conv_verrou_FARTHEST##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_FARTHEST"#OP, vr_conv_verrou_FARTHEST##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_FARTHEST"#OP, vr_unfused_conv_verrou_FARTHEST##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -757,23 +1075,33 @@ if(vr.roundingMode==VR_FLOAT){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP #define bcNameWithCC(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_NEAREST"#OP, vr_unfused_verrou_NEAREST##OP #define bcNameConv(OP) "vr_verrou_FLOAT_soft"#OP, vr_verrou_FLOAT_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_FLOAT_soft"#OP, vr_verrou_FLOAT_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_FLOAT_soft"#OP, vr_unfused_verrou_FLOAT_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP #define bcNameWithCC(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_NEAREST"#OP, vr_unfused_verrou_NEAREST##OP #define bcNameConv(OP) "vr_conv_verrou_FLOAT_soft"#OP, vr_conv_verrou_FLOAT_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_FLOAT_soft"#OP, vr_conv_verrou_FLOAT_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_FLOAT_soft"#OP, vr_unfused_conv_verrou_FLOAT_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv @@ -781,23 +1109,33 @@ if(vr.roundingMode==VR_FLOAT){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP #define bcNameWithCC(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_NEAREST"#OP, vr_unfused_verrou_NEAREST##OP #define bcNameConv(OP) "vr_verrou_FLOAT"#OP, vr_verrou_FLOAT##OP #define bcNameConvWithCC(OP) "vr_verrou_FLOAT"#OP, vr_verrou_FLOAT##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_FLOAT"#OP, vr_unfused_verrou_FLOAT##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP #define bcNameWithCC(OP) "vr_verrou_NEAREST"#OP, vr_verrou_NEAREST##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_NEAREST"#OP, vr_unfused_verrou_NEAREST##OP #define bcNameConv(OP) "vr_conv_verrou_FLOAT"#OP, vr_conv_verrou_FLOAT##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_FLOAT"#OP, vr_conv_verrou_FLOAT##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_FLOAT"#OP, vr_unfused_conv_verrou_FLOAT##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv @@ -808,45 +1146,65 @@ if(vr.roundingMode==VR_PRANDOM){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_PRANDOM_soft"#OP, vr_verrou_PRANDOM_soft##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM_soft"#OP, vr_verrou_PRANDOM_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_soft"#OP, vr_unfused_verrou_PRANDOM_soft##OP #define bcNameConv(OP) "vr_verrou_PRANDOM_soft"#OP, vr_verrou_PRANDOM_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_PRANDOM_soft"#OP, vr_verrou_PRANDOM_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_soft"#OP, vr_unfused_verrou_PRANDOM_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_PRANDOM_soft"#OP, vr_verrou_PRANDOM_soft##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM_soft"#OP, vr_verrou_PRANDOM_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_soft"#OP, vr_unfused_verrou_PRANDOM_soft##OP #define bcNameConv(OP) "vr_conv_verrou_PRANDOM_soft"#OP, vr_conv_verrou_PRANDOM_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_PRANDOM_soft"#OP, vr_conv_verrou_PRANDOM_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_PRANDOM_soft"#OP, vr_unfused_conv_verrou_PRANDOM_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_PRANDOM"#OP, vr_verrou_PRANDOM##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM"#OP, vr_verrou_PRANDOM##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM"#OP, vr_unfused_verrou_PRANDOM##OP #define bcNameConv(OP) "vr_verrou_PRANDOM"#OP, vr_verrou_PRANDOM##OP #define bcNameConvWithCC(OP) "vr_verrou_PRANDOM"#OP, vr_verrou_PRANDOM##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM"#OP, vr_unfused_verrou_PRANDOM##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_PRANDOM"#OP, vr_verrou_PRANDOM##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM"#OP, vr_verrou_PRANDOM##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM"#OP, vr_unfused_verrou_PRANDOM##OP #define bcNameConv(OP) "vr_conv_verrou_PRANDOM"#OP, vr_conv_verrou_PRANDOM##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_PRANDOM"#OP, vr_conv_verrou_PRANDOM##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_PRANDOM"#OP, vr_unfused_conv_verrou_PRANDOM##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -855,45 +1213,65 @@ if(vr.roundingMode==VR_PRANDOM_DET){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_PRANDOM_DET_soft"#OP, vr_verrou_PRANDOM_DET_soft##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM_DET_soft"#OP, vr_verrou_PRANDOM_DET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_DET_soft"#OP, vr_unfused_verrou_PRANDOM_DET_soft##OP #define bcNameConv(OP) "vr_verrou_PRANDOM_DET_soft"#OP, vr_verrou_PRANDOM_DET_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_PRANDOM_DET_soft"#OP, vr_verrou_PRANDOM_DET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_DET_soft"#OP, vr_unfused_verrou_PRANDOM_DET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_PRANDOM_DET_soft"#OP, vr_verrou_PRANDOM_DET_soft##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM_DET_soft"#OP, vr_verrou_PRANDOM_DET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_DET_soft"#OP, vr_unfused_verrou_PRANDOM_DET_soft##OP #define bcNameConv(OP) "vr_conv_verrou_PRANDOM_DET_soft"#OP, vr_conv_verrou_PRANDOM_DET_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_PRANDOM_DET_soft"#OP, vr_conv_verrou_PRANDOM_DET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_PRANDOM_DET_soft"#OP, vr_unfused_conv_verrou_PRANDOM_DET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_PRANDOM_DET"#OP, vr_verrou_PRANDOM_DET##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM_DET"#OP, vr_verrou_PRANDOM_DET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_DET"#OP, vr_unfused_verrou_PRANDOM_DET##OP #define bcNameConv(OP) "vr_verrou_PRANDOM_DET"#OP, vr_verrou_PRANDOM_DET##OP #define bcNameConvWithCC(OP) "vr_verrou_PRANDOM_DET"#OP, vr_verrou_PRANDOM_DET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_DET"#OP, vr_unfused_verrou_PRANDOM_DET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_PRANDOM_DET"#OP, vr_verrou_PRANDOM_DET##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM_DET"#OP, vr_verrou_PRANDOM_DET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_DET"#OP, vr_unfused_verrou_PRANDOM_DET##OP #define bcNameConv(OP) "vr_conv_verrou_PRANDOM_DET"#OP, vr_conv_verrou_PRANDOM_DET##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_PRANDOM_DET"#OP, vr_conv_verrou_PRANDOM_DET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_PRANDOM_DET"#OP, vr_unfused_conv_verrou_PRANDOM_DET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -902,45 +1280,65 @@ if(vr.roundingMode==VR_PRANDOM_COMDET){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_PRANDOM_COMDET_soft"#OP, vr_verrou_PRANDOM_COMDET_soft##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM_COMDET_soft"#OP, vr_verrou_PRANDOM_COMDET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_COMDET_soft"#OP, vr_unfused_verrou_PRANDOM_COMDET_soft##OP #define bcNameConv(OP) "vr_verrou_PRANDOM_COMDET_soft"#OP, vr_verrou_PRANDOM_COMDET_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_PRANDOM_COMDET_soft"#OP, vr_verrou_PRANDOM_COMDET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_COMDET_soft"#OP, vr_unfused_verrou_PRANDOM_COMDET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_PRANDOM_COMDET_soft"#OP, vr_verrou_PRANDOM_COMDET_soft##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM_COMDET_soft"#OP, vr_verrou_PRANDOM_COMDET_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_COMDET_soft"#OP, vr_unfused_verrou_PRANDOM_COMDET_soft##OP #define bcNameConv(OP) "vr_conv_verrou_PRANDOM_COMDET_soft"#OP, vr_conv_verrou_PRANDOM_COMDET_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_PRANDOM_COMDET_soft"#OP, vr_conv_verrou_PRANDOM_COMDET_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_PRANDOM_COMDET_soft"#OP, vr_unfused_conv_verrou_PRANDOM_COMDET_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//instrument hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou_PRANDOM_COMDET"#OP, vr_verrou_PRANDOM_COMDET##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM_COMDET"#OP, vr_verrou_PRANDOM_COMDET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_COMDET"#OP, vr_unfused_verrou_PRANDOM_COMDET##OP #define bcNameConv(OP) "vr_verrou_PRANDOM_COMDET"#OP, vr_verrou_PRANDOM_COMDET##OP #define bcNameConvWithCC(OP) "vr_verrou_PRANDOM_COMDET"#OP, vr_verrou_PRANDOM_COMDET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_COMDET"#OP, vr_unfused_verrou_PRANDOM_COMDET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_PRANDOM_COMDET"#OP, vr_verrou_PRANDOM_COMDET##OP #define bcNameWithCC(OP) "vr_verrou_PRANDOM_COMDET"#OP, vr_verrou_PRANDOM_COMDET##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_PRANDOM_COMDET"#OP, vr_unfused_verrou_PRANDOM_COMDET##OP #define bcNameConv(OP) "vr_conv_verrou_PRANDOM_COMDET"#OP, vr_conv_verrou_PRANDOM_COMDET##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_PRANDOM_COMDET"#OP, vr_conv_verrou_PRANDOM_COMDET##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_PRANDOM_COMDET"#OP, vr_unfused_conv_verrou_PRANDOM_COMDET##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv } } @@ -949,46 +1347,66 @@ if(vr.roundingMode==VR_PRANDOM_COMDET){ if(!vr.float_conv){ #define bcName(OP) "vr_verrou_soft"#OP, vr_verrou_soft##OP #define bcNameWithCC(OP) "vr_verrou_soft"#OP, vr_verrou_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_soft"#OP, vr_unfused_verrou_soft##OP #define bcNameConv(OP) "vr_verrou_soft"#OP, vr_verrou_soft##OP #define bcNameConvWithCC(OP) "vr_verrou_soft"#OP, vr_verrou_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou_soft"#OP, vr_unfused_verrou_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou_soft"#OP, vr_verrou_soft##OP #define bcNameWithCC(OP) "vr_verrou_soft"#OP, vr_verrou_soft##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou_soft"#OP, vr_unfused_verrou_soft##OP #define bcNameConv(OP) "vr_conv_verrou_soft"#OP, vr_conv_verrou_soft##OP #define bcNameConvWithCC(OP) "vr_conv_verrou_soft"#OP, vr_conv_verrou_soft##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou_soft"#OP, vr_unfused_conv_verrou_soft##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }else{//hard if(!vr.float_conv){ #define bcName(OP) "vr_verrou"#OP, vr_verrou##OP #define bcNameWithCC(OP) "vr_verrou"#OP, vr_verrou##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou"#OP, vr_unfused_verrou##OP #define bcNameConv(OP) "vr_verrou"#OP, vr_verrou##OP #define bcNameConvWithCC(OP) "vr_verrou"#OP, vr_verrou##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_verrou"#OP, vr_unfused_verrou##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameConvWithCCUnfused +#undef bcNameWithCCUnfused + }else{//vr.float_conv #define bcName(OP) "vr_verrou"#OP, vr_verrou##OP #define bcNameWithCC(OP) "vr_verrou"#OP, vr_verrou##OP +#define bcNameWithCCUnfused(OP) "vr_unfused_verrou"#OP, vr_unfused_verrou##OP #define bcNameConv(OP) "vr_conv_verrou"#OP, vr_conv_verrou##OP #define bcNameConvWithCC(OP) "vr_conv_verrou"#OP, vr_conv_verrou##OP +#define bcNameConvWithCCUnfused(OP) "vr_unfused_conv_verrou"#OP, vr_unfused_conv_verrou##OP #include "vr_instrumentOp_impl.h" #undef bcName #undef bcNameWithCC #undef bcNameConv #undef bcNameConvWithCC +#undef bcNameWithCCUnfused +#undef bcNameConvWithCCUnfused + }//end float_conv }//end vr.instrument_soft_used) diff --git a/vr_interp_operator_template_3args.h b/vr_interp_operator_template_3args.h index cb13f8f..159f1ab 100644 --- a/vr_interp_operator_template_3args.h +++ b/vr_interp_operator_template_3args.h @@ -56,3 +56,68 @@ static VG_REGPARM(3) Int FCTNAME(32F,) (Long a, Long b, Long c) { Int *d = (Int*)(&res); return *d; } + +//unFusED vERSION + +static VG_REGPARM(3) Long FCTNAMEUNFUSED(64F,) (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + double res; + double res_temp; + PREBACKEND; + BACKEND_FIRST_FUNC(double)(*arg1, *arg2, &res_temp, CONTEXT); + BACKEND_SECOND_FUNC(double)(res_temp, SIGN *arg3, &res, CONTEXT); + POSTBACKEND; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Long FCTCONVNAMEUNFUSED(64F,) (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + double *arg1 = (double*)(&a); + double *arg2 = (double*)(&b); + double *arg3 = (double*)(&c); + float arg1f=*arg1; + float arg2f=*arg2; + float arg3f=*arg3; + + double res; + float resf; + float res_temp; + PREBACKEND; + BACKEND_FIRST_FUNC(float)(arg1f, arg2f, &res_temp, CONTEXT); + BACKEND_SECOND_FUNC(float)(res_temp, SIGN arg3f, &resf, CONTEXT); + POSTBACKEND; + res=resf; +#else + double res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Long *d = (Long*)(&res); + return *d; +} + +static VG_REGPARM(3) Int FCTNAMEUNFUSED(32F,) (Long a, Long b, Long c) { +#ifdef USE_VERROU_FMA + float *arg1 = (float*)(&a); + float *arg2 = (float*)(&b); + float *arg3 = (float*)(&c); + float res; + float res_temp; + PREBACKEND; + BACKEND_FIRST_FUNC(float)(*arg1, *arg2, &res_temp, CONTEXT); + BACKEND_SECOND_FUNC(float)(res_temp, SIGN *arg3, &res, CONTEXT); + POSTBACKEND; +#else + float res=0.; + VG_(tool_panic) ( "Verrou needs to be compiled with FMA support \n"); +#endif + Int *d = (Int*)(&res); + return *d; +} diff --git a/vr_main.c b/vr_main.c index 48f5009..57eb093 100644 --- a/vr_main.c +++ b/vr_main.c @@ -1588,6 +1588,9 @@ static void vr_post_clo_init(void) if(vr.float_conv){ VG_(umsg)("Frontend: double -> float\n"); } + if(vr.unfused){ + VG_(umsg)("Frontend: unfused\n"); + } if(vr.backend==vr_verrou){ VG_(umsg)("Backend verrou simulating %s rounding mode\n", verrou_rounding_mode_name (vr.roundingMode)); diff --git a/vr_main.h b/vr_main.h index bf22aea..0dcc9ba 100644 --- a/vr_main.h +++ b/vr_main.h @@ -135,6 +135,7 @@ typedef struct { Bool instr_vec[VR_VEC]; Bool instr_prec[VR_PREC]; Bool float_conv; + Bool unfused; // Vr_Instr instrument; Vr_Instr instrument_hard;