diff --git a/tools/ExternalFunctionAuto-Completion/DemanglingTools/Demanglingtools b/tools/ExternalFunctionAuto-Completion/DemanglingTools/Demanglingtools new file mode 100755 index 000000000..dcf8148a4 Binary files /dev/null and b/tools/ExternalFunctionAuto-Completion/DemanglingTools/Demanglingtools differ diff --git a/tools/ExternalFunctionAuto-Completion/DemanglingTools/in.json b/tools/ExternalFunctionAuto-Completion/DemanglingTools/in.json new file mode 100644 index 000000000..54893e831 --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/DemanglingTools/in.json @@ -0,0 +1,11 @@ + +{ + "Function" : [ +{ "name":"_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_" }, +{ "name":"_ZNSolsEPFRSoS_E" }, +{ "name":"_ZNSt8ios_base4InitC1Ev" }, +{ "name":"_ZNSolsEd" }, +{ "name":"_ZNSt8ios_base4InitD1Ev" } + + ] + } diff --git a/tools/ExternalFunctionAuto-Completion/DemanglingTools/jsoncpp b/tools/ExternalFunctionAuto-Completion/DemanglingTools/jsoncpp new file mode 160000 index 000000000..8190e061b --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/DemanglingTools/jsoncpp @@ -0,0 +1 @@ +Subproject commit 8190e061bc2d95da37479a638aa2c9e483e58ec6 diff --git a/tools/ExternalFunctionAuto-Completion/DemanglingTools/out.json b/tools/ExternalFunctionAuto-Completion/DemanglingTools/out.json new file mode 100644 index 000000000..f2afc4881 --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/DemanglingTools/out.json @@ -0,0 +1,74 @@ +{ + "Function" : [ + { + "BaseName" : "endl", + "DeclContextName" : "std", + "EntireName" : "std::basic_ostream >& std::endl >(std::basic_ostream >&)", + "FunctionName" : "std::endl >", + "MangledName" : "_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_", + "Parameters" : "(std::basic_ostream >&)", + "ReturnType" : "std::basic_ostream >&", + "hasFunctionQualifiers" : false, + "isCtorOrDtor" : false, + "isData" : false, + "isFunction" : true, + "isSpecialName" : false + }, + { + "BaseName" : "operator<<", + "DeclContextName" : "std::ostream", + "EntireName" : "std::ostream::operator<<(std::ostream& (*)(std::ostream&))", + "FunctionName" : "std::ostream::operator<<", + "MangledName" : "_ZNSolsEPFRSoS_E", + "Parameters" : "(std::ostream& (*)(std::ostream&))", + "ReturnType" : "", + "hasFunctionQualifiers" : false, + "isCtorOrDtor" : false, + "isData" : false, + "isFunction" : true, + "isSpecialName" : false + }, + { + "BaseName" : "Init", + "DeclContextName" : "std::ios_base::Init", + "EntireName" : "std::ios_base::Init::Init()", + "FunctionName" : "std::ios_base::Init::Init", + "MangledName" : "_ZNSt8ios_base4InitC1Ev", + "Parameters" : "()", + "ReturnType" : "", + "hasFunctionQualifiers" : false, + "isCtorOrDtor" : true, + "isData" : false, + "isFunction" : true, + "isSpecialName" : false + }, + { + "BaseName" : "operator<<", + "DeclContextName" : "std::ostream", + "EntireName" : "std::ostream::operator<<(double)", + "FunctionName" : "std::ostream::operator<<", + "MangledName" : "_ZNSolsEd", + "Parameters" : "(double)", + "ReturnType" : "", + "hasFunctionQualifiers" : false, + "isCtorOrDtor" : false, + "isData" : false, + "isFunction" : true, + "isSpecialName" : false + }, + { + "BaseName" : "~Init", + "DeclContextName" : "std::ios_base::Init", + "EntireName" : "std::ios_base::Init::~Init()", + "FunctionName" : "std::ios_base::Init::~Init", + "MangledName" : "_ZNSt8ios_base4InitD1Ev", + "Parameters" : "()", + "ReturnType" : "", + "hasFunctionQualifiers" : false, + "isCtorOrDtor" : true, + "isData" : false, + "isFunction" : true, + "isSpecialName" : false + } + ] +} diff --git a/tools/ExternalFunctionAuto-Completion/DemanglingTools/test.cpp b/tools/ExternalFunctionAuto-Completion/DemanglingTools/test.cpp new file mode 100644 index 000000000..22297f28b --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/DemanglingTools/test.cpp @@ -0,0 +1,164 @@ +//this file is a simple tools to use the llvm/Demangle.h to demangle extern_funcs +#include +#include +#include +#include +#include +#include +#include "llvm/Demangle/Demangle.h" +#include "jsoncpp/include/json/json.h" + + + typedef struct +{ + std::string MangledName; + std::string BaseName; + std::string DeclContextName; + std::string Parameters; + std::string FunctionName; + std::string EntireName; + std::string ReturnType; + bool hasFunctionQualifiers =false; + bool isCtorOrDtor =false; + bool isFunction =false; + bool isData =false; + bool isSpecialName =false; +}MangleNode; + +void readFileJson(std::list* funclist) +{ + Json::Reader reader; + Json::Value root; + + std::ifstream in("in.json", std::ios::binary); + if (!in.is_open()) + { + std::cout << "Error opening file\n"; + return ; + } + if (reader.parse(in, root)) + { + if (root["Function"].isArray()) + { + int nArraySize = root["Function"].size(); + for (int i=0; ipush_back(funcName); + } + } + + } + else + { + std::cout << "parse error\n" << std::endl; + } + in.close(); + +} + +MangleNode DemangleFunction(std::string funcName) +{ + MangleNode MNode; + const char* pcmangledname = funcName.data(); + int size = 0; + int status = 0; + char * demangled = NULL; + char * FunctionReturnType = NULL; + char * FunctionBaseName = NULL; + char * demangled4 = NULL; + char * demangled5 = NULL; + char * demangled6 = NULL; + llvm::ItaniumPartialDemangler IPD; + + IPD.partialDemangle(funcName.data()); + MNode.MangledName=funcName; + MNode.ReturnType= IPD.getFunctionReturnType(NULL, NULL); + MNode.BaseName= IPD.getFunctionBaseName(NULL, NULL); + MNode.DeclContextName= IPD.getFunctionDeclContextName(NULL, NULL); + MNode.FunctionName= IPD.getFunctionName(NULL,NULL); + MNode.Parameters= IPD.getFunctionParameters(NULL,NULL); + MNode.EntireName = llvm::itaniumDemangle(funcName.data(), NULL, NULL, &status); + if(IPD.isCtorOrDtor()) + { + MNode.isCtorOrDtor=true; + } + if(IPD.hasFunctionQualifiers()) + { + MNode.hasFunctionQualifiers=true; + } + if(IPD.isData()) + { + MNode.isData=true; + } + if(IPD.isFunction()) + { + MNode.isFunction=true; + } + if(IPD.isSpecialName()) + { + MNode.isSpecialName=true; + } + + return MNode; + + + + +} + + + + + +int main () +{ + + std::list func_list; + readFileJson(&func_list); + std::list::iterator iter; + Json::Value root; + for(iter=func_list.begin(); iter != func_list.end(); iter++) + { + Json::Value bro; + MangleNode MNode=DemangleFunction(*iter); + bro["MangledName"]=Json::Value(MNode.MangledName); + bro["BaseName"]=Json::Value(MNode.BaseName); + bro["DeclContextName"]=Json::Value(MNode.DeclContextName); + bro["Parameters"]=Json::Value(MNode.Parameters); + bro["ReturnType"]=Json::Value(MNode.ReturnType); + bro["FunctionName"]=Json::Value(MNode.FunctionName); + bro["EntireName"]=Json::Value(MNode.EntireName); + bro["hasFunctionQualifiers"]=Json::Value(MNode.hasFunctionQualifiers); + bro["isCtorOrDtor"]=Json::Value(MNode.isCtorOrDtor); + bro["isFunction"]=Json::Value(MNode.isFunction); + bro["isData"]=Json::Value(MNode.isData); + bro["isSpecialName"]=Json::Value(MNode.isSpecialName); + + root["Function"].append(Json::Value(bro)); + } + std::ofstream os; + os.open("out.json", std::ios::out); + Json::StyledWriter sw; + if (!os.is_open()) + { + std::cout << "error:can't find the file" << std::endl; + } + os << sw.write(root); + os.close(); + + + + + + + + + + + + + //free(demangled); + + return 0; +} \ No newline at end of file diff --git a/tools/ExternalFunctionAuto-Completion/EFAT.py b/tools/ExternalFunctionAuto-Completion/EFAT.py new file mode 100755 index 000000000..6a359ad23 --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/EFAT.py @@ -0,0 +1,540 @@ +#!/usr/bin/env python +#------------------------------------------------------------------------------- +# scripts/readelf.py +# +# A clone of 'readelf' in Python, based on the pyelftools library +# +# Eli Bendersky (eliben@gmail.com) +# This code is in the public domain +# +# above is the comments of the original pyreadelf project +# this file is based of pyreadelf +#------------------------------------------------------------------------------- +import argparse +import time +import os, sys +import string +import re +import traceback +import itertools +import json +from collections import defaultdict +# Note: zip has different behaviour between Python 2.x and 3.x. +# - Using izip ensures compatibility. +try: + from itertools import izip +except: + izip = zip + +# For running from development directory. It should take precedence over the +# installed pyelftools. +sys.path.insert(0, '.') + + +from elftools import __version__ +from elftools.common.exceptions import ELFError +from elftools.common.utils import bytes2str, iterbytes +from elftools.elf.elffile import ELFFile +from elftools.elf.dynamic import DynamicSection, DynamicSegment +from elftools.elf.sections import ( + NoteSection, SymbolTableSection, SymbolTableIndexSection +) +from elftools.elf.gnuversions import ( + GNUVerSymSection, GNUVerDefSection, + GNUVerNeedSection, + ) +from elftools.elf.relocation import RelocationSection +from elftools.elf.descriptions import ( + describe_ei_class, describe_e_machine, + ) + + +from elftools.dwarf.locationlists import LocationParser, LocationEntry, LocationViewPair, BaseAddressEntry as LocBaseAddressEntry, LocationListsPair +from elftools.dwarf.ranges import RangeEntry, BaseAddressEntry as RangeBaseAddressEntry, RangeListsPair + + +#A list of functions include from glibc +GLIBC_FUNCDECL_LIST = defaultdict(list) +#A list of functions include from glibc +GLIBCXX_FUNCDECL_LIST = defaultdict(list) + +#the libc/libcxx_header must be the same with /dict/libc/libcxx.h +#things the libs below did't include all the libs,you can add new libs here. + +libcxx_header = """ +#include +""" + + +libc_header = """ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +""" + + +#the context used to write json file +json_header = """ +{ + "Function" : [ +""" +json_end = """ + ] + } +""" + +#the context used to write completion.cpp +cxx_header1 = """ + // mcsema ABI library, automatically generated by generate_abi_wrapper.py + extern "C" { +""" + +cxx_header2 = """ +} + +__attribute__((used)) void *__mcsema_externs[] = { +""" +#the context used to write completion.c +c_header = """ + +__attribute__((used)) void *__mcsema_externs[] = { +""" +cORcxx_end = """ +}; +""" + + + +# a class which referemce the llvm/Demangle.h，which include the key consept of Demangled Func +class MangleNode: + def __init__(self): + self.MangledName = "" + self.BaseName = "" + self.DeclContextName = "" + self.Parameters = "" + self.FunctionName = "" + self.EntireName = "" + self.ReturnType = "" + self.hasFunctionQualifiers =False + self.isCtorOrDtor =False + self.isFunction =False + self.isData =False + self.isSpecialName =False + + + + +class ReadElf(object): + """ display_* methods are used to emit output into the output stream + """ + def __init__(self, file, output): + """ file: + stream object with the ELF file to read + + output: + output stream to write to + """ + self.elffile = ELFFile(file) + self.output = output + + # Lazily initialized if a debug dump is requested + self._dwarfinfo = None + + self._versioninfo = None + + self._shndx_sections = None + + + # By modifying this function, the automation from parsing the elf file symbol table to + # generating supplementary function definitions is realized + def demangle_symbol_tables_and_generate_complement_functions(self): + #Anomaly detection that preserves the integrity of the symbol table in the original script + self._init_versioninfo() + + symbol_tables = [(idx, s) for idx, s in enumerate(self.elffile.iter_sections()) + if isinstance(s, SymbolTableSection)] + + if not symbol_tables and self.elffile.num_sections() == 0: + self._emitline('') + self._emitline('Dynamic symbol information is not available for' + ' displaying symbols.') + GCCLib_path = os.environ['LIFT_GCC_LIB_PATH'] + cpp_flag=False + continue_flag=False + #an elf file has many sections in smytalbes,like '.dynsym','.symtab', + # in order to cover most of the extern func，we loop all the sections. + for section_index, section in symbol_tables: + if not isinstance(section, SymbolTableSection): + continue + + if section['sh_entsize'] == 0: + self._emitline("\nSymbol table '%s' has a sh_entsize of zero!" % ( + section.name)) + continue + + self._emitline("\nSymbol table '%s' contains %d %s:" % ( + section.name, + section.num_symbols(), + 'entry' if section.num_symbols() == 1 else 'entries')) + + #This loop is implemented for the main function, which reads the symbol table and processes + for nsym, symbol in enumerate(section.iter_symbols()): + #Read the symbol table, only take TYPE=FUNC, Ndx=UND + if (symbol['st_info'] ['type']== 'STT_FUNC' and + symbol['st_shndx'] == 'SHN_UNDEF'): + # There is no clear sign in the elf file that the program is a C++ program. + # Here we judge whether the program is a C++ program by + # checking whether the Name Mangling function exists in the symbol table. + if cpp_flag==False: + if symbol.name [0:2]=="_Z": + cpp_flag=True + #The elf file on the x86 platform will have a suffix of ***@@GLIBCXX_3.4 + # after the thing taken out of .symtab (one less @ on Arm) + libCorCXXverson_obj=re.search('@+GLIBC[A-Za-z]*_[0-9,.]+',symbol.name) + if libCorCXXverson_obj !=None: + #For the time being, only those with the GLIBC*** logo are processed. + funcName=symbol.name[0:libCorCXXverson_obj.regs[0][0]] + libVersionName=symbol.name[libCorCXXverson_obj.regs[0][0]: ] + if re.search('GLIBCXX',libVersionName): + key=funcName + GLIBCXX_FUNCDECL_LIST[key].append("1") + continue_flag=True + else: + key=funcName + GLIBC_FUNCDECL_LIST[key].append("1") + continue_flag=True + + #If the program to be translated is a C++ program and there are extern_functions after Name_Mangling + if continue_flag==True: + if cpp_flag and len(GLIBCXX_FUNCDECL_LIST)!=0: + DemangleToolsPath = os.path.dirname(os.path.abspath(__file__))+"/../DemanglingTools/" + outfile=DemangleToolsPath+"in.json" + #First hand over the recognized mangled function to the + #C++ internal interface of llvm for processing + write_json_file(outfile) + + print("start to write in.json (if 0 success) ") + time.sleep(2) + print(os.system("cat "+outfile)) + DemangleToolsCommand = DemangleToolsPath+"Demanglingtools" + print(os.chdir("../DemanglingTools/")) + print(os.system(DemangleToolsCommand)) + #Read the processed result + inputjsonfile=DemangleToolsPath+"out.json" + print(os.chdir("../pyelftools/")) + #print(os.system("cat "+inputjsonfile)) + with open(inputjsonfile, 'r') as json_file: + json_data = json.load(json_file) + + #write the Complement.c/cpp + abioutfile=os.path.dirname(os.path.abspath(__file__))+"/../Result/" + write_cxx_abi_file(abioutfile,json_data,GCCLib_path) + else: + abioutfile=os.path.dirname(os.path.abspath(__file__))+"/../Result/" + write_c_abi_file(abioutfile,GCCLib_path) + + else: + print("There was a problem parsing the symbol table. end of program") + sys.exit() + + #Complement.c/cpp has been generated so far, + #and finally the corresponding supplementary LLVMIR is generated + if cpp_flag == True: + compiler="clang++" + liftingFile=abioutfile+"complement.cpp" + else: + compiler="clang" + liftingFile=abioutfile+"complement.c" + + LiftCommand=compiler+ " -emit-llvm -c "+ liftingFile+ " -o" +abioutfile+"liftedComplement.bc" + + + print(os.system(LiftCommand)) + LLVMdisCommand="llvm-dis " +abioutfile+"liftedComplement.bc" + print(os.system(LLVMdisCommand)) + + + + + + + + + + + def _init_versioninfo(self): + """ Search and initialize informations about version related sections + and the kind of versioning used (GNU or Solaris). + """ + if self._versioninfo is not None: + return + + self._versioninfo = {'versym': None, 'verdef': None, + 'verneed': None, 'type': None} + + for section in self.elffile.iter_sections(): + if isinstance(section, GNUVerSymSection): + self._versioninfo['versym'] = section + elif isinstance(section, GNUVerDefSection): + self._versioninfo['verdef'] = section + elif isinstance(section, GNUVerNeedSection): + self._versioninfo['verneed'] = section + elif isinstance(section, DynamicSection): + for tag in section.iter_tags(): + if tag['d_tag'] == 'DT_VERSYM': + self._versioninfo['type'] = 'GNU' + break + + if not self._versioninfo['type'] and ( + self._versioninfo['verneed'] or self._versioninfo['verdef']): + self._versioninfo['type'] = 'Solaris' + + def _emit(self, s=''): + """ Emit an object to output + """ + self.output.write(str(s)) + + def _emitline(self, s=''): + """ Emit an object to output, followed by a newline + """ + self.output.write(str(s).rstrip() + '\n') + + +SCRIPT_DESCRIPTION = 'Display information about the contents of ELF format files' +VERSION_STRING = '%%(prog)s: based on pyelftools %s' % __version__ + + +def main(stream=None): + # parse the command-line arguments and invoke ReadElf + argparser = argparse.ArgumentParser( + usage='usage: %(prog)s [options] ', + description=SCRIPT_DESCRIPTION, + add_help=False, # -h is a real option of readelf + prog='readelf.py') + argparser.add_argument('file', + nargs='?', default=None, + help='ELF file to parse') + argparser.add_argument('-v', '--version', + action='version', version=VERSION_STRING) + argparser.add_argument('-H', '--help', + action='store_true', dest='help', + help='Display this information') + argparser.add_argument('-h', '--file-header', + action='store_true', dest='show_file_header', + help='Display the ELF file header') + argparser.add_argument('-l', '--program-headers', '--segments', + action='store_true', dest='show_program_header', + help='Display the program headers') + argparser.add_argument('-S', '--section-headers', '--sections', + action='store_true', dest='show_section_header', + help="Display the sections' headers") + argparser.add_argument('-e', '--headers', + action='store_true', dest='show_all_headers', + help='Equivalent to: -h -l -S') + #Call the method that generates the supplementary function by registering a new parameter + argparser.add_argument('-complement', + action='store_true', dest='demangle_and_complement_symbols', + help='Demangle the symbol table and generate complement functions for mcsema') + + + args = argparser.parse_args() + + if args.help or not args.file: + argparser.print_help() + sys.exit(0) + + if args.show_all_headers: + do_file_header = do_section_header = do_program_header = True + else: + do_file_header = args.show_file_header + do_section_header = args.show_section_header + do_program_header = args.show_program_header + + with open(args.file, 'rb') as file: + try: + readelf = ReadElf(file, stream or sys.stdout) + if do_file_header: + readelf.display_file_header() + if do_section_header: + readelf.display_section_headers( + show_heading=not do_file_header) + if do_program_header: + readelf.display_program_headers( + show_heading=not do_file_header) + #Add the corresponding registration function call of -complement + if args.demangle_and_complement_symbols: + readelf.demangle_symbol_tables_and_generate_complement_functions() + + except ELFError as ex: + sys.stdout.flush() + sys.stderr.write('ELF error: %s\n' % ex) + if args.show_traceback: + traceback.print_exc() + sys.exit(1) + + +def write_cxx_abi_file(outfile,jsonDict,allDictPath): + """ Generate ABI library source for the c headers; + """ + # generate the abi lib cxx file + dictPath=allDictPath + outfile=outfile+"complement.cpp" + with open(outfile, "w") as s: + #Write the include header file first + s.write(libcxx_header) + + s.write(cxx_header1) + #The first layer of loops traverses FUNCDECL_LIST + for value in jsonDict["Function"]: + value["canBeComplement"]=False + if value.get("ReturnType") != "": + s.write("{0} {1} {2};".format(value.get("ReturnType"),value.get("MangledName"),value.get("Parameters"))) + s.write("\n") + value["canBeComplement"]=True + elif value.get("isCtorOrDtor") ==True: + s.write("void {1} {2};".format(value.get("ReturnType"),value.get("MangledName"),value.get("Parameters"))) + s.write("\n") + value["canBeComplement"]=True + elif re.search('std::[A-Za-z]+',value.get("DeclContextName")): + s.write("{0} {1} {2};".format(value.get("DeclContextName"),value.get("MangledName"),value.get("Parameters"))) + s.write("\n") + value["canBeComplement"]=True + else: + sys.path.append(dictPath) + print(dictPath) + from allcxxdict import dict + CXXSearchDict=dict.dictionary + if CXXSearchDict.get(value.get("BaseName"))!=None: + if isinstance(CXXSearchDict.get(value.get("BaseName")),list): + for funcs in CXXSearchDict.get(value.get("BaseName")): + if funcs[1]==value.get("Parameters"): + s.write("{0} {1} {2};".format(funcs[0],value.get("MangledName"),value.get("Parameters"))) + s.write("\n") + value["canBeComplement"]=True + else: + s.write("{0} {1} {2};".format(CXXSearchDict.get(value.get("BaseName")),value.get("MangledName"),value.get("Parameters"))) + s.write("\n") + value["canBeComplement"]=True + else: + print(value.get("MangledName")) + print(" unable to supplement\n") + s.write(cxx_header2) + + + for value in jsonDict["Function"]: + if value["canBeComplement"]==True: + s.write("(void *) {0},".format(value["MangledName"])) + s.write("\n") + for key in GLIBC_FUNCDECL_LIST.keys(): + sys.path.append(dictPath) + print(dictPath) + from allcxxdict import dict + CXXSearchDict=dict.dictionary + if CXXSearchDict.get(key)!=None: + if isinstance(CXXSearchDict.get(key),list): + print(key) + print(" unable to supplement\n") + else: + s.write("(void *) {0},".format(key)) + s.write("\n") + else: + print(key) + print(" unable to supplement\n") + + + s.write(cORcxx_end) + +def write_c_abi_file(outfile,allDictPath): + """ Generate ABI library source for the c headers; + """ + # generate the abi lib cc file + outfile=outfile+"complement.c" + dictPath=allDictPath + with open(outfile, "w") as s: + #Write the include header file first + s.write(libc_header) + + s.write(c_header) + for key in GLIBC_FUNCDECL_LIST.keys(): + sys.path.append(dictPath) + from allcdict import dict + CSearchDict=dict.dictionary + if CSearchDict.get(key)!=None: + s.write("(void *) {0},".format(key)) + s.write("\n") + else: + print(key) + print(" unable to supplement\n") + + + s.write(cORcxx_end) + + + + + +def write_json_file(outfile): + """ Generate json library source for the Demangling tools; + """ + with open(outfile, "w") as s: + s.truncate() + s.write(json_header) + #遍历GLIBCXX_FUNCDECL_LIST + i=0 + num=len(GLIBCXX_FUNCDECL_LIST) + for key in GLIBCXX_FUNCDECL_LIST.keys(): + str="{ \"name\":\""+key+"\" }" + s.write(str) + i=i+1 + if i!=num: + s.write(",") + s.write("\n") + s.write(json_end) + + + + + +def profile_main(): + # Run 'main' redirecting its output to readelfout.txt + # Saves profiling information in readelf.profile + PROFFILE = 'readelf.profile' + import cProfile + cProfile.run('main(open("readelfout.txt", "w"))', PROFFILE) + + # Dig in some profiling stats + import pstats + p = pstats.Stats(PROFFILE) + p.sort_stats('cumulative').print_stats(25) + + +#------------------------------------------------------------------------------- +if __name__ == '__main__': + main() + #profile_main() diff --git a/tools/ExternalFunctionAuto-Completion/README.md b/tools/ExternalFunctionAuto-Completion/README.md new file mode 100644 index 000000000..f6415d712 --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/README.md @@ -0,0 +1,92 @@ +# Static External Functions Auto-completion tool + +this tool is an External Functions Auto-completion tool. External functions are those functions that are dynamically linked and referenced from header files. (such as libc, libstdc++) + +the input of this tool is an elf file, and the output is a llvm IR which include the completed external functions' definations. + +to use this tool ,you have to make sure the gcc version on your platform is larger than the targeting elf file(you'd better install the latest gcc on your computer). + +this tool has been tested to work on x86-64 Ubuntu20.04. + + The image below shows the overall architecture of the tool. + +![Image text](https://github.com/Stephen-lei/anvill/blob/master/tools/ExternalFunctionAuto-Completion/framework.png) + + +# Dependencies +to use this tool,you have to install : + +| Name | Version | +| ---------------------------------------------------------- | ------- | +| [jsoncpp](https://github.com/open-source-parsers/jsoncpp) | Latest | +| [llvm](https://github.com/llvm/llvm-project) | 11.0+ | +| [Clang](http://clang.llvm.org/) | 11.0+ | +| [pyelftools](https://github.com/eliben/pyelftools) | Latest | + + +## How to use +1.put the EFAT.py under the pyelftools dir,the file structure must be the same with the template below. + + + |-- ExternalFunctionAuto-Completion + |-- DemanglingTools/ + |--jsoncpp(clone from github and build) + |--llvm(builed llvm library in you computer,you have to copy it from /usr/lib/llvm-**/include/llvm) + |--test.cpp + |-- dict/ + |-- pyelftools(clone source code from github,no need to build,just pip install)/ + |--EFAT.py + |--elftools + |--... + |-- test/ + |-- Result/ + |-- README.md + |-- generate_glibc_dict.py + + + +2.set environment 'LIFT_GCC_LIB_PATH' to point to the "dict" dir + + + export LIFT_GCC_LIB_PATH="(path).../dict" + +3.type command: + + + python EFAT.py -complement ../test/X86/MotivatingExample + +4.the outputfile will generated in the 'Result' directory + + + + +## Detailed introduction of other parts +The project also has two sub-components, namely the C++ Demangling sub-module and the dict supplementary sub-module. The following describes how to use them respectively. + +## C++ Demangling sub-module +this sub-module is written by c++,and based on [jsoncpp](https://github.com/open-source-parsers/jsoncpp) and llvm/Demangle.h. To build the tools, you have to make sure the structure above. + +your platform may have some error while lunching the Demanglingtools(elf)，we recommend you to regenerate the Demanglingtools,try: + + +first clone the jsoncpp, and build it(see the dev.makefile in this projext). Then: + + clang++ -g test.cpp -o Demanglingtools (path to your llvm)/lib/libLLVMDemangle.a (path)/jsoncpp/build/debug/lib/libjsoncpp.a + + +## Dict supplementary sub-module +This submodule is mainly responsible for parsing an AST tree containing header files of external libraries, and parsing function definitions (such as return values and parameters, etc.) from it. This information can assist the implementation of automation tools. + +Now the libc.h and libcxx.h only include some common header files in gcc, not all the header files. the coverage of header files will affect the auto-completion rate. you can include more headers in these files.(also change the definition in EFAT.py) + +to regenerate the dict library,try: + + export CLANG_EXE="/usr/lib/llvm-11/bin/clang" (point to your clang) + + export CLANG_LIB="/usr/lib/llvm-11/lib/libclang-**.so.1" (point to your libclang.so) + + python generate_glibc_dict.py + --type c + --input ./dict/libc.h + --output ./dict/allcdict.py + diff --git a/tools/ExternalFunctionAuto-Completion/Result/complement.cpp b/tools/ExternalFunctionAuto-Completion/Result/complement.cpp new file mode 100644 index 000000000..61472a9cd --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/Result/complement.cpp @@ -0,0 +1,22 @@ + +#include + + // mcsema ABI library, automatically generated by generate_abi_wrapper.py + extern "C" { +std::basic_ostream >& _ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_ (std::basic_ostream >&); +std::ostream _ZNSolsEPFRSoS_E (std::ostream& (*)(std::ostream&)); +void _ZNSt8ios_base4InitC1Ev (); +std::ostream _ZNSolsEd (double); +void _ZNSt8ios_base4InitD1Ev (); + +} + +__attribute__((used)) void *__mcsema_externs[] = { +(void *) _ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_, +(void *) _ZNSolsEPFRSoS_E, +(void *) _ZNSt8ios_base4InitC1Ev, +(void *) _ZNSolsEd, +(void *) _ZNSt8ios_base4InitD1Ev, +(void *) printf, + +}; diff --git a/tools/ExternalFunctionAuto-Completion/Result/liftedComplement.bc b/tools/ExternalFunctionAuto-Completion/Result/liftedComplement.bc new file mode 100644 index 000000000..6dd2080c3 Binary files /dev/null and b/tools/ExternalFunctionAuto-Completion/Result/liftedComplement.bc differ diff --git a/tools/ExternalFunctionAuto-Completion/Result/liftedComplement.ll b/tools/ExternalFunctionAuto-Completion/Result/liftedComplement.ll new file mode 100644 index 000000000..a3087de97 --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/Result/liftedComplement.ll @@ -0,0 +1,67 @@ +; ModuleID = '/home/zyl/Stephen_Github/anvill/tools/ExternalFunctionAuto-Completion/pyelftools/../Result/liftedComplement.bc' +source_filename = "/home/zyl/Stephen_Github/anvill/tools/ExternalFunctionAuto-Completion/pyelftools/../Result/complement.cpp" +target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-pc-linux-gnu" + +%"class.std::ios_base::Init" = type { i8 } +%"class.std::basic_ostream" = type { i32 (...)**, %"class.std::basic_ios" } +%"class.std::basic_ios" = type { %"class.std::ios_base", %"class.std::basic_ostream"*, i8, i8, %"class.std::basic_streambuf"*, %"class.std::ctype"*, %"class.std::num_put"*, %"class.std::num_get"* } +%"class.std::ios_base" = type { i32 (...)**, i64, i64, i32, i32, i32, %"struct.std::ios_base::_Callback_list"*, %"struct.std::ios_base::_Words", [8 x %"struct.std::ios_base::_Words"], i32, %"struct.std::ios_base::_Words"*, %"class.std::locale" } +%"struct.std::ios_base::_Callback_list" = type { %"struct.std::ios_base::_Callback_list"*, void (i32, %"class.std::ios_base"*, i32)*, i32, i32 } +%"struct.std::ios_base::_Words" = type { i8*, i64 } +%"class.std::locale" = type { %"class.std::locale::_Impl"* } +%"class.std::locale::_Impl" = type { i32, %"class.std::locale::facet"**, i64, %"class.std::locale::facet"**, i8** } +%"class.std::locale::facet" = type <{ i32 (...)**, i32, [4 x i8] }> +%"class.std::basic_streambuf" = type { i32 (...)**, i8*, i8*, i8*, i8*, i8*, i8*, %"class.std::locale" } +%"class.std::ctype" = type <{ %"class.std::locale::facet.base", [4 x i8], %struct.__locale_struct*, i8, [7 x i8], i32*, i32*, i16*, i8, [256 x i8], [256 x i8], i8, [6 x i8] }> +%"class.std::locale::facet.base" = type <{ i32 (...)**, i32 }> +%struct.__locale_struct = type { [13 x %struct.__locale_data*], i16*, i32*, i32*, [13 x i8*] } +%struct.__locale_data = type opaque +%"class.std::num_put" = type { %"class.std::locale::facet.base", [4 x i8] } +%"class.std::num_get" = type { %"class.std::locale::facet.base", [4 x i8] } + +@_ZStL8__ioinit = internal global %"class.std::ios_base::Init" zeroinitializer, align 1 +@__dso_handle = external hidden global i8 +@__mcsema_externs = dso_local global [6 x i8*] [i8* bitcast (%"class.std::basic_ostream"* (%"class.std::basic_ostream"*)* @_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_ to i8*), i8* bitcast (void (%"class.std::basic_ostream"*, %"class.std::basic_ostream"* (%"class.std::basic_ostream"*)*)* @_ZNSolsEPFRSoS_E to i8*), i8* bitcast (void (%"class.std::ios_base::Init"*)* @_ZNSt8ios_base4InitC1Ev to i8*), i8* bitcast (void (%"class.std::basic_ostream"*, double)* @_ZNSolsEd to i8*), i8* bitcast (void (%"class.std::ios_base::Init"*)* @_ZNSt8ios_base4InitD1Ev to i8*), i8* bitcast (i32 (i8*, ...)* @printf to i8*)], align 16 +@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_complement.cpp, i8* null }] +@llvm.used = appending global [1 x i8*] [i8* bitcast ([6 x i8*]* @__mcsema_externs to i8*)], section "llvm.metadata" + +; Function Attrs: noinline uwtable +define internal void @__cxx_global_var_init() #0 section ".text.startup" { + call void @_ZNSt8ios_base4InitC1Ev(%"class.std::ios_base::Init"* @_ZStL8__ioinit) + %1 = call i32 @__cxa_atexit(void (i8*)* bitcast (void (%"class.std::ios_base::Init"*)* @_ZNSt8ios_base4InitD1Ev to void (i8*)*), i8* getelementptr inbounds (%"class.std::ios_base::Init", %"class.std::ios_base::Init"* @_ZStL8__ioinit, i32 0, i32 0), i8* @__dso_handle) #3 + ret void +} + +declare dso_local void @_ZNSt8ios_base4InitC1Ev(%"class.std::ios_base::Init"*) unnamed_addr #1 + +; Function Attrs: nounwind +declare dso_local void @_ZNSt8ios_base4InitD1Ev(%"class.std::ios_base::Init"*) unnamed_addr #2 + +; Function Attrs: nounwind +declare dso_local i32 @__cxa_atexit(void (i8*)*, i8*, i8*) #3 + +declare dso_local nonnull align 8 dereferenceable(8) %"class.std::basic_ostream"* @_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_(%"class.std::basic_ostream"* nonnull align 8 dereferenceable(8)) #1 + +declare dso_local void @_ZNSolsEPFRSoS_E(%"class.std::basic_ostream"* sret align 8, %"class.std::basic_ostream"* (%"class.std::basic_ostream"*)*) #1 + +declare dso_local void @_ZNSolsEd(%"class.std::basic_ostream"* sret align 8, double) #1 + +declare dso_local i32 @printf(i8*, ...) #1 + +; Function Attrs: noinline uwtable +define internal void @_GLOBAL__sub_I_complement.cpp() #0 section ".text.startup" { + call void @__cxx_global_var_init() + ret void +} + +attributes #0 = { noinline uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #1 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #2 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #3 = { nounwind } + +!llvm.module.flags = !{!0} +!llvm.ident = !{!1} + +!0 = !{i32 1, !"wchar_size", i32 4} +!1 = !{!"Ubuntu clang version 11.1.0-6"} diff --git a/tools/ExternalFunctionAuto-Completion/dict/allcdict.py b/tools/ExternalFunctionAuto-Completion/dict/allcdict.py new file mode 100644 index 000000000..c07dd363c --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/dict/allcdict.py @@ -0,0 +1,1462 @@ + +class dict: + dictionary={ + +"__assert_fail":"void", +"__assert_perror_fail":"void", +"__assert":"void", +"__ctype_b_loc":"const unsigned short **", +"__ctype_tolower_loc":"const __int32_t **", +"__ctype_toupper_loc":"const __int32_t **", +"isalnum":"int", +"isalpha":"int", +"iscntrl":"int", +"isdigit":"int", +"islower":"int", +"isgraph":"int", +"isprint":"int", +"ispunct":"int", +"isspace":"int", +"isupper":"int", +"isxdigit":"int", +"tolower":"int", +"toupper":"int", +"isblank":"int", +"isascii":"int", +"toascii":"int", +"_toupper":"int", +"_tolower":"int", +"isalnum_l":"int", +"isalpha_l":"int", +"iscntrl_l":"int", +"isdigit_l":"int", +"islower_l":"int", +"isgraph_l":"int", +"isprint_l":"int", +"ispunct_l":"int", +"isspace_l":"int", +"isupper_l":"int", +"isxdigit_l":"int", +"isblank_l":"int", +"__tolower_l":"int", +"tolower_l":"int", +"__toupper_l":"int", +"toupper_l":"int", +"__errno_location":"int *", +"setlocale":"char *", +"localeconv":"struct lconv *", +"newlocale":"locale_t", +"duplocale":"locale_t", +"freelocale":"void", +"uselocale":"locale_t", +"__fpclassify":"int", +"__signbit":"int", +"__isinf":"int", +"__finite":"int", +"__isnan":"int", +"__iseqsig":"int", +"__issignaling":"int", +"acos":"double", +"__acos":"double", +"asin":"double", +"__asin":"double", +"atan":"double", +"__atan":"double", +"atan2":"double", +"__atan2":"double", +"cos":"double", +"__cos":"double", +"sin":"double", +"__sin":"double", +"tan":"double", +"__tan":"double", +"cosh":"double", +"__cosh":"double", +"sinh":"double", +"__sinh":"double", +"tanh":"double", +"__tanh":"double", +"acosh":"double", +"__acosh":"double", +"asinh":"double", +"__asinh":"double", +"atanh":"double", +"__atanh":"double", +"exp":"double", +"__exp":"double", +"frexp":"double", +"__frexp":"double", +"ldexp":"double", +"__ldexp":"double", +"log":"double", +"__log":"double", +"log10":"double", +"__log10":"double", +"modf":"double", +"__modf":"double", +"expm1":"double", +"__expm1":"double", +"log1p":"double", +"__log1p":"double", +"logb":"double", +"__logb":"double", +"exp2":"double", +"__exp2":"double", +"log2":"double", +"__log2":"double", +"pow":"double", +"__pow":"double", +"sqrt":"double", +"__sqrt":"double", +"hypot":"double", +"__hypot":"double", +"cbrt":"double", +"__cbrt":"double", +"ceil":"double", +"__ceil":"double", +"fabs":"double", +"__fabs":"double", +"floor":"double", +"__floor":"double", +"fmod":"double", +"__fmod":"double", +"isinf":"int", +"finite":"int", +"drem":"double", +"__drem":"double", +"significand":"double", +"__significand":"double", +"copysign":"double", +"__copysign":"double", +"nan":"double", +"__nan":"double", +"isnan":"int", +"j0":"double", +"__j0":"double", +"j1":"double", +"__j1":"double", +"jn":"double", +"__jn":"double", +"y0":"double", +"__y0":"double", +"y1":"double", +"__y1":"double", +"yn":"double", +"__yn":"double", +"erf":"double", +"__erf":"double", +"erfc":"double", +"__erfc":"double", +"lgamma":"double", +"__lgamma":"double", +"tgamma":"double", +"__tgamma":"double", +"gamma":"double", +"__gamma":"double", +"lgamma_r":"double", +"__lgamma_r":"double", +"rint":"double", +"__rint":"double", +"nextafter":"double", +"__nextafter":"double", +"nexttoward":"double", +"__nexttoward":"double", +"remainder":"double", +"__remainder":"double", +"scalbn":"double", +"__scalbn":"double", +"ilogb":"int", +"__ilogb":"int", +"scalbln":"double", +"__scalbln":"double", +"nearbyint":"double", +"__nearbyint":"double", +"round":"double", +"__round":"double", +"trunc":"double", +"__trunc":"double", +"remquo":"double", +"__remquo":"double", +"lrint":"long", +"__lrint":"long", +"llrint":"long long", +"__llrint":"long long", +"lround":"long", +"__lround":"long", +"llround":"long long", +"__llround":"long long", +"fdim":"double", +"__fdim":"double", +"fmax":"double", +"__fmax":"double", +"fmin":"double", +"__fmin":"double", +"fma":"double", +"__fma":"double", +"scalb":"double", +"__scalb":"double", +"__fpclassifyf":"int", +"__signbitf":"int", +"__isinff":"int", +"__finitef":"int", +"__isnanf":"int", +"__iseqsigf":"int", +"__issignalingf":"int", +"acosf":"float", +"__acosf":"float", +"asinf":"float", +"__asinf":"float", +"atanf":"float", +"__atanf":"float", +"atan2f":"float", +"__atan2f":"float", +"cosf":"float", +"__cosf":"float", +"sinf":"float", +"__sinf":"float", +"tanf":"float", +"__tanf":"float", +"coshf":"float", +"__coshf":"float", +"sinhf":"float", +"__sinhf":"float", +"tanhf":"float", +"__tanhf":"float", +"acoshf":"float", +"__acoshf":"float", +"asinhf":"float", +"__asinhf":"float", +"atanhf":"float", +"__atanhf":"float", +"expf":"float", +"__expf":"float", +"frexpf":"float", +"__frexpf":"float", +"ldexpf":"float", +"__ldexpf":"float", +"logf":"float", +"__logf":"float", +"log10f":"float", +"__log10f":"float", +"modff":"float", +"__modff":"float", +"expm1f":"float", +"__expm1f":"float", +"log1pf":"float", +"__log1pf":"float", +"logbf":"float", +"__logbf":"float", +"exp2f":"float", +"__exp2f":"float", +"log2f":"float", +"__log2f":"float", +"powf":"float", +"__powf":"float", +"sqrtf":"float", +"__sqrtf":"float", +"hypotf":"float", +"__hypotf":"float", +"cbrtf":"float", +"__cbrtf":"float", +"ceilf":"float", +"__ceilf":"float", +"fabsf":"float", +"__fabsf":"float", +"floorf":"float", +"__floorf":"float", +"fmodf":"float", +"__fmodf":"float", +"isinff":"int", +"finitef":"int", +"dremf":"float", +"__dremf":"float", +"significandf":"float", +"__significandf":"float", +"copysignf":"float", +"__copysignf":"float", +"nanf":"float", +"__nanf":"float", +"isnanf":"int", +"j0f":"float", +"__j0f":"float", +"j1f":"float", +"__j1f":"float", +"jnf":"float", +"__jnf":"float", +"y0f":"float", +"__y0f":"float", +"y1f":"float", +"__y1f":"float", +"ynf":"float", +"__ynf":"float", +"erff":"float", +"__erff":"float", +"erfcf":"float", +"__erfcf":"float", +"lgammaf":"float", +"__lgammaf":"float", +"tgammaf":"float", +"__tgammaf":"float", +"gammaf":"float", +"__gammaf":"float", +"lgammaf_r":"float", +"__lgammaf_r":"float", +"rintf":"float", +"__rintf":"float", +"nextafterf":"float", +"__nextafterf":"float", +"nexttowardf":"float", +"__nexttowardf":"float", +"remainderf":"float", +"__remainderf":"float", +"scalbnf":"float", +"__scalbnf":"float", +"ilogbf":"int", +"__ilogbf":"int", +"scalblnf":"float", +"__scalblnf":"float", +"nearbyintf":"float", +"__nearbyintf":"float", +"roundf":"float", +"__roundf":"float", +"truncf":"float", +"__truncf":"float", +"remquof":"float", +"__remquof":"float", +"lrintf":"long", +"__lrintf":"long", +"llrintf":"long long", +"__llrintf":"long long", +"lroundf":"long", +"__lroundf":"long", +"llroundf":"long long", +"__llroundf":"long long", +"fdimf":"float", +"__fdimf":"float", +"fmaxf":"float", +"__fmaxf":"float", +"fminf":"float", +"__fminf":"float", +"fmaf":"float", +"__fmaf":"float", +"scalbf":"float", +"__scalbf":"float", +"__fpclassifyl":"int", +"__signbitl":"int", +"__isinfl":"int", +"__finitel":"int", +"__isnanl":"int", +"__iseqsigl":"int", +"__issignalingl":"int", +"acosl":"long double", +"__acosl":"long double", +"asinl":"long double", +"__asinl":"long double", +"atanl":"long double", +"__atanl":"long double", +"atan2l":"long double", +"__atan2l":"long double", +"cosl":"long double", +"__cosl":"long double", +"sinl":"long double", +"__sinl":"long double", +"tanl":"long double", +"__tanl":"long double", +"coshl":"long double", +"__coshl":"long double", +"sinhl":"long double", +"__sinhl":"long double", +"tanhl":"long double", +"__tanhl":"long double", +"acoshl":"long double", +"__acoshl":"long double", +"asinhl":"long double", +"__asinhl":"long double", +"atanhl":"long double", +"__atanhl":"long double", +"expl":"long double", +"__expl":"long double", +"frexpl":"long double", +"__frexpl":"long double", +"ldexpl":"long double", +"__ldexpl":"long double", +"logl":"long double", +"__logl":"long double", +"log10l":"long double", +"__log10l":"long double", +"modfl":"long double", +"__modfl":"long double", +"expm1l":"long double", +"__expm1l":"long double", +"log1pl":"long double", +"__log1pl":"long double", +"logbl":"long double", +"__logbl":"long double", +"exp2l":"long double", +"__exp2l":"long double", +"log2l":"long double", +"__log2l":"long double", +"powl":"long double", +"__powl":"long double", +"sqrtl":"long double", +"__sqrtl":"long double", +"hypotl":"long double", +"__hypotl":"long double", +"cbrtl":"long double", +"__cbrtl":"long double", +"ceill":"long double", +"__ceill":"long double", +"fabsl":"long double", +"__fabsl":"long double", +"floorl":"long double", +"__floorl":"long double", +"fmodl":"long double", +"__fmodl":"long double", +"isinfl":"int", +"finitel":"int", +"dreml":"long double", +"__dreml":"long double", +"significandl":"long double", +"__significandl":"long double", +"copysignl":"long double", +"__copysignl":"long double", +"nanl":"long double", +"__nanl":"long double", +"isnanl":"int", +"j0l":"long double", +"__j0l":"long double", +"j1l":"long double", +"__j1l":"long double", +"jnl":"long double", +"__jnl":"long double", +"y0l":"long double", +"__y0l":"long double", +"y1l":"long double", +"__y1l":"long double", +"ynl":"long double", +"__ynl":"long double", +"erfl":"long double", +"__erfl":"long double", +"erfcl":"long double", +"__erfcl":"long double", +"lgammal":"long double", +"__lgammal":"long double", +"tgammal":"long double", +"__tgammal":"long double", +"gammal":"long double", +"__gammal":"long double", +"lgammal_r":"long double", +"__lgammal_r":"long double", +"rintl":"long double", +"__rintl":"long double", +"nextafterl":"long double", +"__nextafterl":"long double", +"nexttowardl":"long double", +"__nexttowardl":"long double", +"remainderl":"long double", +"__remainderl":"long double", +"scalbnl":"long double", +"__scalbnl":"long double", +"ilogbl":"int", +"__ilogbl":"int", +"scalblnl":"long double", +"__scalblnl":"long double", +"nearbyintl":"long double", +"__nearbyintl":"long double", +"roundl":"long double", +"__roundl":"long double", +"truncl":"long double", +"__truncl":"long double", +"remquol":"long double", +"__remquol":"long double", +"lrintl":"long", +"__lrintl":"long", +"llrintl":"long long", +"__llrintl":"long long", +"lroundl":"long", +"__lroundl":"long", +"llroundl":"long long", +"__llroundl":"long long", +"fdiml":"long double", +"__fdiml":"long double", +"fmaxl":"long double", +"__fmaxl":"long double", +"fminl":"long double", +"__fminl":"long double", +"fmal":"long double", +"__fmal":"long double", +"scalbl":"long double", +"__scalbl":"long double", +"setjmp":"int", +"__sigsetjmp":"int", +"_setjmp":"int", +"longjmp":"void", +"_longjmp":"void", +"siglongjmp":"void", +"__sysv_signal":"__sighandler_t", +"signal":"__sighandler_t", +"kill":"int", +"killpg":"int", +"raise":"int", +"ssignal":"__sighandler_t", +"gsignal":"int", +"psignal":"void", +"psiginfo":"void", +"sigblock":"int", +"sigsetmask":"int", +"siggetmask":"int", +"sigemptyset":"int", +"sigfillset":"int", +"sigaddset":"int", +"sigdelset":"int", +"sigismember":"int", +"sigprocmask":"int", +"sigsuspend":"int", +"sigaction":"int", +"sigpending":"int", +"sigwait":"int", +"sigwaitinfo":"int", +"sigtimedwait":"int", +"sigqueue":"int", +"sigreturn":"int", +"siginterrupt":"int", +"sigaltstack":"int", +"sigstack":"int", +"pthread_sigmask":"int", +"pthread_kill":"int", +"__libc_current_sigrtmin":"int", +"__libc_current_sigrtmax":"int", +"remove":"int", +"rename":"int", +"renameat":"int", +"fclose":"int", +"tmpfile":"FILE *", +"tmpnam":"char *", +"tmpnam_r":"char *", +"tempnam":"char *", +"fflush":"int", +"fflush_unlocked":"int", +"fopen":"FILE *", +"freopen":"FILE *", +"fdopen":"FILE *", +"fmemopen":"FILE *", +"open_memstream":"FILE *", +"setbuf":"void", +"setvbuf":"int", +"setbuffer":"void", +"setlinebuf":"void", +"fprintf":"int", +"printf":"int", +"sprintf":"int", +"vfprintf":"int", +"vprintf":"int", +"vsprintf":"int", +"snprintf":"int", +"vsnprintf":"int", +"vdprintf":"int", +"dprintf":"int", +"fscanf":"int", +"fscanf":"int", +"scanf":"int", +"scanf":"int", +"sscanf":"int", +"sscanf":"int", +"vfscanf":"int", +"vfscanf":"int", +"vscanf":"int", +"vscanf":"int", +"vsscanf":"int", +"vsscanf":"int", +"fgetc":"int", +"getc":"int", +"getchar":"int", +"getc_unlocked":"int", +"getchar_unlocked":"int", +"fgetc_unlocked":"int", +"fputc":"int", +"putc":"int", +"putchar":"int", +"fputc_unlocked":"int", +"putc_unlocked":"int", +"putchar_unlocked":"int", +"getw":"int", +"putw":"int", +"fgets":"char *", +"__getdelim":"__ssize_t", +"getdelim":"__ssize_t", +"getline":"__ssize_t", +"fputs":"int", +"puts":"int", +"ungetc":"int", +"fread":"unsigned long", +"fwrite":"unsigned long", +"fread_unlocked":"size_t", +"fwrite_unlocked":"size_t", +"fseek":"int", +"ftell":"long", +"rewind":"void", +"fseeko":"int", +"ftello":"__off_t", +"fgetpos":"int", +"fsetpos":"int", +"clearerr":"void", +"feof":"int", +"ferror":"int", +"clearerr_unlocked":"void", +"feof_unlocked":"int", +"ferror_unlocked":"int", +"perror":"void", +"fileno":"int", +"fileno_unlocked":"int", +"pclose":"int", +"popen":"FILE *", +"ctermid":"char *", +"flockfile":"void", +"ftrylockfile":"int", +"funlockfile":"void", +"__uflow":"int", +"__overflow":"int", +"__ctype_get_mb_cur_max":"size_t", +"atof":"double", +"atoi":"int", +"atol":"long", +"atoll":"long long", +"strtod":"double", +"strtof":"float", +"strtold":"long double", +"strtol":"long", +"strtoul":"unsigned long", +"strtoq":"long long", +"strtouq":"unsigned long long", +"strtoll":"long long", +"strtoull":"unsigned long long", +"l64a":"char *", +"a64l":"long", +"__bswap_16":"__uint16_t", +"__bswap_32":"__uint32_t", +"__bswap_64":"__uint64_t", +"__uint16_identity":"__uint16_t", +"__uint32_identity":"__uint32_t", +"__uint64_identity":"__uint64_t", +"select":"int", +"pselect":"int", +"random":"long", +"srandom":"void", +"initstate":"char *", +"setstate":"char *", +"random_r":"int", +"srandom_r":"int", +"initstate_r":"int", +"setstate_r":"int", +"rand":"int", +"srand":"void", +"rand_r":"int", +"drand48":"double", +"erand48":"double", +"lrand48":"long", +"nrand48":"long", +"mrand48":"long", +"jrand48":"long", +"srand48":"void", +"seed48":"unsigned short *", +"lcong48":"void", +"drand48_r":"int", +"erand48_r":"int", +"lrand48_r":"int", +"nrand48_r":"int", +"mrand48_r":"int", +"jrand48_r":"int", +"srand48_r":"int", +"seed48_r":"int", +"lcong48_r":"int", +"malloc":"void *", +"calloc":"void *", +"realloc":"void *", +"free":"void", +"reallocarray":"void *", +"reallocarray":"void *", +"alloca":"void *", +"valloc":"void *", +"posix_memalign":"int", +"aligned_alloc":"void *", +"abort":"void", +"atexit":"int", +"at_quick_exit":"int", +"on_exit":"int", +"exit":"void", +"quick_exit":"void", +"_Exit":"void", +"getenv":"char *", +"putenv":"int", +"setenv":"int", +"unsetenv":"int", +"clearenv":"int", +"mktemp":"char *", +"mkstemp":"int", +"mkstemps":"int", +"mkdtemp":"char *", +"system":"int", +"realpath":"char *", +"bsearch":"void *", +"qsort":"void", +"abs":"int", +"labs":"long", +"llabs":"long long", +"div":"div_t", +"ldiv":"ldiv_t", +"lldiv":"lldiv_t", +"ecvt":"char *", +"fcvt":"char *", +"gcvt":"char *", +"qecvt":"char *", +"qfcvt":"char *", +"qgcvt":"char *", +"ecvt_r":"int", +"fcvt_r":"int", +"qecvt_r":"int", +"qfcvt_r":"int", +"mblen":"int", +"mbtowc":"int", +"wctomb":"int", +"mbstowcs":"size_t", +"wcstombs":"size_t", +"rpmatch":"int", +"getsubopt":"int", +"getloadavg":"int", +"memcpy":"void *", +"memmove":"void *", +"memccpy":"void *", +"memset":"void *", +"memcmp":"int", +"__memcmpeq":"int", +"memchr":"void *", +"strcpy":"char *", +"strncpy":"char *", +"strcat":"char *", +"strncat":"char *", +"strcmp":"int", +"strncmp":"int", +"strcoll":"int", +"strxfrm":"unsigned long", +"strcoll_l":"int", +"strxfrm_l":"size_t", +"strdup":"char *", +"strndup":"char *", +"strchr":"char *", +"strrchr":"char *", +"strcspn":"unsigned long", +"strspn":"unsigned long", +"strpbrk":"char *", +"strstr":"char *", +"strtok":"char *", +"__strtok_r":"char *", +"strtok_r":"char *", +"strlen":"unsigned long", +"strnlen":"size_t", +"strerror":"char *", +"strerror_r":"int", +"strerror_l":"char *", +"bcmp":"int", +"bcopy":"void", +"bzero":"void", +"index":"char *", +"rindex":"char *", +"ffs":"int", +"ffsl":"int", +"ffsll":"int", +"strcasecmp":"int", +"strncasecmp":"int", +"strcasecmp_l":"int", +"strncasecmp_l":"int", +"explicit_bzero":"void", +"strsep":"char *", +"strsignal":"char *", +"__stpcpy":"char *", +"stpcpy":"char *", +"__stpncpy":"char *", +"stpncpy":"char *", +"clock":"clock_t", +"time":"time_t", +"difftime":"double", +"mktime":"time_t", +"strftime":"size_t", +"strftime_l":"size_t", +"gmtime":"struct tm *", +"localtime":"struct tm *", +"gmtime_r":"struct tm *", +"localtime_r":"struct tm *", +"asctime":"char *", +"ctime":"char *", +"asctime_r":"char *", +"ctime_r":"char *", +"tzset":"void", +"timegm":"time_t", +"timelocal":"time_t", +"dysize":"int", +"nanosleep":"int", +"clock_getres":"int", +"clock_gettime":"int", +"clock_settime":"int", +"clock_nanosleep":"int", +"clock_getcpuclockid":"int", +"timer_create":"int", +"timer_delete":"int", +"timer_settime":"int", +"timer_gettime":"int", +"timer_getoverrun":"int", +"timespec_get":"int", +"wcscpy":"wchar_t *", +"wcsncpy":"wchar_t *", +"wcscat":"wchar_t *", +"wcsncat":"wchar_t *", +"wcscmp":"int", +"wcsncmp":"int", +"wcscasecmp":"int", +"wcsncasecmp":"int", +"wcscasecmp_l":"int", +"wcsncasecmp_l":"int", +"wcscoll":"int", +"wcsxfrm":"size_t", +"wcscoll_l":"int", +"wcsxfrm_l":"size_t", +"wcsdup":"wchar_t *", +"wcschr":"int *", +"wcsrchr":"wchar_t *", +"wcscspn":"size_t", +"wcsspn":"size_t", +"wcspbrk":"wchar_t *", +"wcsstr":"wchar_t *", +"wcstok":"wchar_t *", +"wcslen":"unsigned long", +"wcsnlen":"size_t", +"wmemchr":"int *", +"wmemcmp":"int", +"wmemcpy":"int *", +"wmemmove":"int *", +"wmemset":"wchar_t *", +"btowc":"wint_t", +"wctob":"int", +"mbsinit":"int", +"mbrtowc":"size_t", +"wcrtomb":"size_t", +"__mbrlen":"size_t", +"mbrlen":"size_t", +"mbsrtowcs":"size_t", +"wcsrtombs":"size_t", +"mbsnrtowcs":"size_t", +"wcsnrtombs":"size_t", +"wcstod":"double", +"wcstof":"float", +"wcstold":"long double", +"wcstol":"long", +"wcstoul":"unsigned long", +"wcstoll":"long long", +"wcstoull":"unsigned long long", +"wcpcpy":"wchar_t *", +"wcpncpy":"wchar_t *", +"open_wmemstream":"__FILE *", +"fwide":"int", +"fwprintf":"int", +"wprintf":"int", +"swprintf":"int", +"vfwprintf":"int", +"vwprintf":"int", +"vswprintf":"int", +"fwscanf":"int", +"fwscanf":"int", +"wscanf":"int", +"wscanf":"int", +"swscanf":"int", +"swscanf":"int", +"vfwscanf":"int", +"vfwscanf":"int", +"vwscanf":"int", +"vwscanf":"int", +"vswscanf":"int", +"vswscanf":"int", +"fgetwc":"wint_t", +"getwc":"wint_t", +"getwchar":"wint_t", +"fputwc":"wint_t", +"putwc":"wint_t", +"putwchar":"wint_t", +"fgetws":"wchar_t *", +"fputws":"int", +"ungetwc":"wint_t", +"wcsftime":"size_t", +"iswalnum":"int", +"iswalpha":"int", +"iswcntrl":"int", +"iswdigit":"int", +"iswgraph":"int", +"iswlower":"int", +"iswprint":"int", +"iswpunct":"int", +"iswspace":"int", +"iswupper":"int", +"iswxdigit":"int", +"iswblank":"int", +"wctype":"wctype_t", +"iswctype":"int", +"towlower":"wint_t", +"towupper":"wint_t", +"wctrans":"wctrans_t", +"towctrans":"wint_t", +"iswalnum_l":"int", +"iswalpha_l":"int", +"iswcntrl_l":"int", +"iswdigit_l":"int", +"iswgraph_l":"int", +"iswlower_l":"int", +"iswprint_l":"int", +"iswpunct_l":"int", +"iswspace_l":"int", +"iswupper_l":"int", +"iswxdigit_l":"int", +"iswblank_l":"int", +"wctype_l":"wctype_t", +"iswctype_l":"int", +"towlower_l":"wint_t", +"towupper_l":"wint_t", +"wctrans_l":"wctrans_t", +"towctrans_l":"wint_t", +"cacos":"void *", +"__cacos":"void *", +"casin":"void *", +"__casin":"void *", +"catan":"void *", +"__catan":"void *", +"ccos":"void *", +"__ccos":"void *", +"csin":"void *", +"__csin":"void *", +"ctan":"void *", +"__ctan":"void *", +"cacosh":"void *", +"__cacosh":"void *", +"casinh":"void *", +"__casinh":"void *", +"catanh":"void *", +"__catanh":"void *", +"ccosh":"void *", +"__ccosh":"void *", +"csinh":"void *", +"__csinh":"void *", +"ctanh":"void *", +"__ctanh":"void *", +"cexp":"void *", +"__cexp":"void *", +"clog":"void *", +"__clog":"void *", +"cpow":"void *", +"__cpow":"void *", +"csqrt":"void *", +"__csqrt":"void *", +"cabs":"void *", +"__cabs":"void *", +"carg":"void *", +"__carg":"void *", +"conj":"void *", +"__conj":"void *", +"cproj":"void *", +"__cproj":"void *", +"cimag":"void *", +"__cimag":"void *", +"creal":"void *", +"__creal":"void *", +"cacosf":"void *", +"__cacosf":"void *", +"casinf":"void *", +"__casinf":"void *", +"catanf":"void *", +"__catanf":"void *", +"ccosf":"void *", +"__ccosf":"void *", +"csinf":"void *", +"__csinf":"void *", +"ctanf":"void *", +"__ctanf":"void *", +"cacoshf":"void *", +"__cacoshf":"void *", +"casinhf":"void *", +"__casinhf":"void *", +"catanhf":"void *", +"__catanhf":"void *", +"ccoshf":"void *", +"__ccoshf":"void *", +"csinhf":"void *", +"__csinhf":"void *", +"ctanhf":"void *", +"__ctanhf":"void *", +"cexpf":"void *", +"__cexpf":"void *", +"clogf":"void *", +"__clogf":"void *", +"cpowf":"void *", +"__cpowf":"void *", +"csqrtf":"void *", +"__csqrtf":"void *", +"cabsf":"void *", +"__cabsf":"void *", +"cargf":"void *", +"__cargf":"void *", +"conjf":"void *", +"__conjf":"void *", +"cprojf":"void *", +"__cprojf":"void *", +"cimagf":"void *", +"__cimagf":"void *", +"crealf":"void *", +"__crealf":"void *", +"cacosl":"void *", +"__cacosl":"void *", +"casinl":"void *", +"__casinl":"void *", +"catanl":"void *", +"__catanl":"void *", +"ccosl":"void *", +"__ccosl":"void *", +"csinl":"void *", +"__csinl":"void *", +"ctanl":"void *", +"__ctanl":"void *", +"cacoshl":"void *", +"__cacoshl":"void *", +"casinhl":"void *", +"__casinhl":"void *", +"catanhl":"void *", +"__catanhl":"void *", +"ccoshl":"void *", +"__ccoshl":"void *", +"csinhl":"void *", +"__csinhl":"void *", +"ctanhl":"void *", +"__ctanhl":"void *", +"cexpl":"void *", +"__cexpl":"void *", +"clogl":"void *", +"__clogl":"void *", +"cpowl":"void *", +"__cpowl":"void *", +"csqrtl":"void *", +"__csqrtl":"void *", +"cabsl":"void *", +"__cabsl":"void *", +"cargl":"void *", +"__cargl":"void *", +"conjl":"void *", +"__conjl":"void *", +"cprojl":"void *", +"__cprojl":"void *", +"cimagl":"void *", +"__cimagl":"void *", +"creall":"void *", +"__creall":"void *", +"feclearexcept":"int", +"fegetexceptflag":"int", +"feraiseexcept":"int", +"fesetexceptflag":"int", +"fetestexcept":"int", +"fegetround":"int", +"fesetround":"int", +"fegetenv":"int", +"feholdexcept":"int", +"fesetenv":"int", +"feupdateenv":"int", +"imaxabs":"intmax_t", +"imaxdiv":"imaxdiv_t", +"strtoimax":"intmax_t", +"strtoumax":"uintmax_t", +"wcstoimax":"intmax_t", +"wcstoumax":"uintmax_t", +"__tg_promote":"_Argument_type_is_not_arithmetic", +"__tg_promote":"double", +"__tg_promote":"double", +"__tg_promote":"double", +"__tg_promote":"double", +"__tg_promote":"double", +"__tg_promote":"double", +"__tg_promote":"float", +"__tg_promote":"double", +"__tg_promote":"long double", +"__tg_promote":"void *", +"__tg_promote":"void *", +"__tg_promote":"void *", +"__tg_acos":"float", +"__tg_acos":"double", +"__tg_acos":"long double", +"__tg_acos":"void *", +"__tg_acos":"void *", +"__tg_acos":"void *", +"__tg_asin":"float", +"__tg_asin":"double", +"__tg_asin":"long double", +"__tg_asin":"void *", +"__tg_asin":"void *", +"__tg_asin":"void *", +"__tg_atan":"float", +"__tg_atan":"double", +"__tg_atan":"long double", +"__tg_atan":"void *", +"__tg_atan":"void *", +"__tg_atan":"void *", +"__tg_acosh":"float", +"__tg_acosh":"double", +"__tg_acosh":"long double", +"__tg_acosh":"void *", +"__tg_acosh":"void *", +"__tg_acosh":"void *", +"__tg_asinh":"float", +"__tg_asinh":"double", +"__tg_asinh":"long double", +"__tg_asinh":"void *", +"__tg_asinh":"void *", +"__tg_asinh":"void *", +"__tg_atanh":"float", +"__tg_atanh":"double", +"__tg_atanh":"long double", +"__tg_atanh":"void *", +"__tg_atanh":"void *", +"__tg_atanh":"void *", +"__tg_cos":"float", +"__tg_cos":"double", +"__tg_cos":"long double", +"__tg_cos":"void *", +"__tg_cos":"void *", +"__tg_cos":"void *", +"__tg_sin":"float", +"__tg_sin":"double", +"__tg_sin":"long double", +"__tg_sin":"void *", +"__tg_sin":"void *", +"__tg_sin":"void *", +"__tg_tan":"float", +"__tg_tan":"double", +"__tg_tan":"long double", +"__tg_tan":"void *", +"__tg_tan":"void *", +"__tg_tan":"void *", +"__tg_cosh":"float", +"__tg_cosh":"double", +"__tg_cosh":"long double", +"__tg_cosh":"void *", +"__tg_cosh":"void *", +"__tg_cosh":"void *", +"__tg_sinh":"float", +"__tg_sinh":"double", +"__tg_sinh":"long double", +"__tg_sinh":"void *", +"__tg_sinh":"void *", +"__tg_sinh":"void *", +"__tg_tanh":"float", +"__tg_tanh":"double", +"__tg_tanh":"long double", +"__tg_tanh":"void *", +"__tg_tanh":"void *", +"__tg_tanh":"void *", +"__tg_exp":"float", +"__tg_exp":"double", +"__tg_exp":"long double", +"__tg_exp":"void *", +"__tg_exp":"void *", +"__tg_exp":"void *", +"__tg_log":"float", +"__tg_log":"double", +"__tg_log":"long double", +"__tg_log":"void *", +"__tg_log":"void *", +"__tg_log":"void *", +"__tg_pow":"float", +"__tg_pow":"double", +"__tg_pow":"long double", +"__tg_pow":"void *", +"__tg_pow":"void *", +"__tg_pow":"void *", +"__tg_sqrt":"float", +"__tg_sqrt":"double", +"__tg_sqrt":"long double", +"__tg_sqrt":"void *", +"__tg_sqrt":"void *", +"__tg_sqrt":"void *", +"__tg_fabs":"float", +"__tg_fabs":"double", +"__tg_fabs":"long double", +"__tg_fabs":"void *", +"__tg_fabs":"void *", +"__tg_fabs":"void *", +"__tg_atan2":"float", +"__tg_atan2":"double", +"__tg_atan2":"long double", +"__tg_cbrt":"float", +"__tg_cbrt":"double", +"__tg_cbrt":"long double", +"__tg_ceil":"float", +"__tg_ceil":"double", +"__tg_ceil":"long double", +"__tg_copysign":"float", +"__tg_copysign":"double", +"__tg_copysign":"long double", +"__tg_erf":"float", +"__tg_erf":"double", +"__tg_erf":"long double", +"__tg_erfc":"float", +"__tg_erfc":"double", +"__tg_erfc":"long double", +"__tg_exp2":"float", +"__tg_exp2":"double", +"__tg_exp2":"long double", +"__tg_expm1":"float", +"__tg_expm1":"double", +"__tg_expm1":"long double", +"__tg_fdim":"float", +"__tg_fdim":"double", +"__tg_fdim":"long double", +"__tg_floor":"float", +"__tg_floor":"double", +"__tg_floor":"long double", +"__tg_fma":"float", +"__tg_fma":"double", +"__tg_fma":"long double", +"__tg_fmax":"float", +"__tg_fmax":"double", +"__tg_fmax":"long double", +"__tg_fmin":"float", +"__tg_fmin":"double", +"__tg_fmin":"long double", +"__tg_fmod":"float", +"__tg_fmod":"double", +"__tg_fmod":"long double", +"__tg_frexp":"float", +"__tg_frexp":"double", +"__tg_frexp":"long double", +"__tg_hypot":"float", +"__tg_hypot":"double", +"__tg_hypot":"long double", +"__tg_ilogb":"int", +"__tg_ilogb":"int", +"__tg_ilogb":"int", +"__tg_ldexp":"float", +"__tg_ldexp":"double", +"__tg_ldexp":"long double", +"__tg_lgamma":"float", +"__tg_lgamma":"double", +"__tg_lgamma":"long double", +"__tg_llrint":"long long", +"__tg_llrint":"long long", +"__tg_llrint":"long long", +"__tg_llround":"long long", +"__tg_llround":"long long", +"__tg_llround":"long long", +"__tg_log10":"float", +"__tg_log10":"double", +"__tg_log10":"long double", +"__tg_log1p":"float", +"__tg_log1p":"double", +"__tg_log1p":"long double", +"__tg_log2":"float", +"__tg_log2":"double", +"__tg_log2":"long double", +"__tg_logb":"float", +"__tg_logb":"double", +"__tg_logb":"long double", +"__tg_lrint":"long", +"__tg_lrint":"long", +"__tg_lrint":"long", +"__tg_lround":"long", +"__tg_lround":"long", +"__tg_lround":"long", +"__tg_nearbyint":"float", +"__tg_nearbyint":"double", +"__tg_nearbyint":"long double", +"__tg_nextafter":"float", +"__tg_nextafter":"double", +"__tg_nextafter":"long double", +"__tg_nexttoward":"float", +"__tg_nexttoward":"double", +"__tg_nexttoward":"long double", +"__tg_remainder":"float", +"__tg_remainder":"double", +"__tg_remainder":"long double", +"__tg_remquo":"float", +"__tg_remquo":"double", +"__tg_remquo":"long double", +"__tg_rint":"float", +"__tg_rint":"double", +"__tg_rint":"long double", +"__tg_round":"float", +"__tg_round":"double", +"__tg_round":"long double", +"__tg_scalbn":"float", +"__tg_scalbn":"double", +"__tg_scalbn":"long double", +"__tg_scalbln":"float", +"__tg_scalbln":"double", +"__tg_scalbln":"long double", +"__tg_tgamma":"float", +"__tg_tgamma":"double", +"__tg_tgamma":"long double", +"__tg_trunc":"float", +"__tg_trunc":"double", +"__tg_trunc":"long double", +"__tg_carg":"float", +"__tg_carg":"double", +"__tg_carg":"long double", +"__tg_carg":"void *", +"__tg_carg":"void *", +"__tg_carg":"void *", +"__tg_cimag":"float", +"__tg_cimag":"double", +"__tg_cimag":"long double", +"__tg_cimag":"void *", +"__tg_cimag":"void *", +"__tg_cimag":"void *", +"__tg_conj":"void *", +"__tg_conj":"void *", +"__tg_conj":"void *", +"__tg_conj":"void *", +"__tg_conj":"void *", +"__tg_conj":"void *", +"__tg_cproj":"void *", +"__tg_cproj":"void *", +"__tg_cproj":"void *", +"__tg_cproj":"void *", +"__tg_cproj":"void *", +"__tg_cproj":"void *", +"__tg_creal":"float", +"__tg_creal":"double", +"__tg_creal":"long double", +"__tg_creal":"void *", +"__tg_creal":"void *", +"__tg_creal":"void *", +"mbrtoc16":"size_t", +"c16rtomb":"size_t", +"mbrtoc32":"size_t", +"c32rtomb":"size_t", +"access":"int", +"faccessat":"int", +"lseek":"__off_t", +"close":"int", +"closefrom":"void", +"read":"ssize_t", +"write":"ssize_t", +"pread":"ssize_t", +"pwrite":"ssize_t", +"pipe":"int", +"alarm":"unsigned int", +"sleep":"unsigned int", +"ualarm":"__useconds_t", +"usleep":"int", +"pause":"int", +"chown":"int", +"fchown":"int", +"lchown":"int", +"fchownat":"int", +"chdir":"int", +"fchdir":"int", +"getcwd":"char *", +"getwd":"char *", +"dup":"int", +"dup2":"int", +"execve":"int", +"fexecve":"int", +"execv":"int", +"execle":"int", +"execl":"int", +"execvp":"int", +"execlp":"int", +"nice":"int", +"_exit":"void", +"pathconf":"long", +"fpathconf":"long", +"sysconf":"long", +"confstr":"size_t", +"getpid":"__pid_t", +"getppid":"__pid_t", +"getpgrp":"__pid_t", +"__getpgid":"__pid_t", +"getpgid":"__pid_t", +"setpgid":"int", +"setpgrp":"int", +"setsid":"__pid_t", +"getsid":"__pid_t", +"getuid":"__uid_t", +"geteuid":"__uid_t", +"getgid":"__gid_t", +"getegid":"__gid_t", +"getgroups":"int", +"setuid":"int", +"setreuid":"int", +"seteuid":"int", +"setgid":"int", +"setregid":"int", +"setegid":"int", +"fork":"__pid_t", +"vfork":"int", +"ttyname":"char *", +"ttyname_r":"int", +"isatty":"int", +"ttyslot":"int", +"link":"int", +"linkat":"int", +"symlink":"int", +"readlink":"ssize_t", +"symlinkat":"int", +"readlinkat":"ssize_t", +"unlink":"int", +"unlinkat":"int", +"rmdir":"int", +"tcgetpgrp":"__pid_t", +"tcsetpgrp":"int", +"getlogin":"char *", +"getlogin_r":"int", +"setlogin":"int", +"getopt":"int", +"gethostname":"int", +"sethostname":"int", +"sethostid":"int", +"getdomainname":"int", +"setdomainname":"int", +"vhangup":"int", +"revoke":"int", +"profil":"int", +"acct":"int", +"getusershell":"char *", +"endusershell":"void", +"setusershell":"void", +"daemon":"int", +"chroot":"int", +"getpass":"char *", +"fsync":"int", +"gethostid":"long", +"sync":"void", +"getpagesize":"int", +"getdtablesize":"int", +"truncate":"int", +"ftruncate":"int", +"brk":"int", +"sbrk":"void *", +"syscall":"long", +"lockf":"int", +"fdatasync":"int", +"crypt":"char *", +"getentropy":"int", +"stat":"int", +"fstat":"int", +"fstatat":"int", +"lstat":"int", +"chmod":"int", +"lchmod":"int", +"fchmod":"int", +"fchmodat":"int", +"umask":"__mode_t", +"mkdir":"int", +"mkdirat":"int", +"mknod":"int", +"mknodat":"int", +"mkfifo":"int", +"mkfifoat":"int", +"utimensat":"int", +"futimens":"int", + + } + diff --git a/tools/ExternalFunctionAuto-Completion/dict/allcxxdict.py b/tools/ExternalFunctionAuto-Completion/dict/allcxxdict.py new file mode 100644 index 000000000..202d56c71 --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/dict/allcxxdict.py @@ -0,0 +1,2441 @@ + +class dict: + dictionary={ + +"__assert_fail":"void", +"__assert_perror_fail":"void", +"__assert":"void", +"__ctype_b_loc":"const unsigned short **", +"__ctype_tolower_loc":"const __int32_t **", +"__ctype_toupper_loc":"const __int32_t **", +"isalnum":"int", +"isalpha":"int", +"iscntrl":"int", +"isdigit":"int", +"islower":"int", +"isgraph":"int", +"isprint":"int", +"ispunct":"int", +"isspace":"int", +"isupper":"int", +"isxdigit":"int", +"tolower":"int", +"toupper":"int", +"isblank":"int", +"isctype":"int", +"isascii":"int", +"toascii":"int", +"_toupper":"int", +"_tolower":"int", +"isalnum_l":"int", +"isalpha_l":"int", +"iscntrl_l":"int", +"isdigit_l":"int", +"islower_l":"int", +"isgraph_l":"int", +"isprint_l":"int", +"ispunct_l":"int", +"isspace_l":"int", +"isupper_l":"int", +"isxdigit_l":"int", +"isblank_l":"int", +"__tolower_l":"int", +"tolower_l":"int", +"__toupper_l":"int", +"toupper_l":"int", +"__errno_location":"int *", +"__sysconf":"long", +"setlocale":"char *", +"localeconv":"struct lconv *", +"newlocale":"locale_t", +"duplocale":"locale_t", +"freelocale":"void", +"uselocale":"locale_t", +"__is_null_pointer":"bool", +"__fpclassify":"int", +"__signbit":"int", +"__isinf":"int", +"__finite":"int", +"__isnan":"int", +"__iseqsig":"int", +"__issignaling":"int", +"acos":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__acos":"double", +"asin":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__asin":"double", +"atan":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__atan":"double", +"atan2":[("double","(double, double)"),("float","(float, float)"),("long double","(long double, long double)")], +"__atan2":"double", +"cos":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__cos":"double", +"sin":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__sin":"double", +"tan":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__tan":"double", +"cosh":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__cosh":"double", +"sinh":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__sinh":"double", +"tanh":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__tanh":"double", +"sincos":"void", +"__sincos":"void", +"acosh":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__acosh":"double", +"asinh":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__asinh":"double", +"atanh":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__atanh":"double", +"exp":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__exp":"double", +"frexp":[("double","(double, int *)"),("float","(float, int *)"),("long double","(long double, int *)")], +"__frexp":"double", +"ldexp":[("double","(double, int)"),("float","(float, int)"),("long double","(long double, int)")], +"__ldexp":"double", +"log":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__log":"double", +"log10":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__log10":"double", +"modf":[("double","(double, double *)"),("float","(float, float *)"),("long double","(long double, long double *)")], +"__modf":"double", +"exp10":"double", +"__exp10":"double", +"expm1":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__expm1":"double", +"log1p":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__log1p":"double", +"logb":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__logb":"double", +"exp2":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__exp2":"double", +"log2":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__log2":"double", +"pow":[("double","(double, double)"),("float","(float, float)"),("long double","(long double, long double)")], +"__pow":"double", +"sqrt":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__sqrt":"double", +"hypot":[("double","(double, double)"),("float","(float, float)"),("long double","(long double, long double)")], +"__hypot":"double", +"cbrt":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__cbrt":"double", +"ceil":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__ceil":"double", +"fabs":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__fabs":"double", +"floor":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__floor":"double", +"fmod":[("double","(double, double)"),("float","(float, float)"),("long double","(long double, long double)")], +"__fmod":"double", +"finite":"int", +"drem":"double", +"__drem":"double", +"significand":"double", +"__significand":"double", +"copysign":[("double","(double, double)"),("float","(float, float)"),("long double","(long double, long double)")], +"__copysign":"double", +"nan":"double", +"__nan":"double", +"j0":"double", +"__j0":"double", +"j1":"double", +"__j1":"double", +"jn":"double", +"__jn":"double", +"y0":"double", +"__y0":"double", +"y1":"double", +"__y1":"double", +"yn":"double", +"__yn":"double", +"erf":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__erf":"double", +"erfc":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__erfc":"double", +"lgamma":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__lgamma":"double", +"tgamma":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__tgamma":"double", +"gamma":"double", +"__gamma":"double", +"lgamma_r":"double", +"__lgamma_r":"double", +"rint":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__rint":"double", +"nextafter":[("double","(double, double)"),("float","(float, float)"),("long double","(long double, long double)")], +"__nextafter":"double", +"nexttoward":[("double","(double, long double)"),("float","(float, long double)"),("long double","(long double, long double)")], +"__nexttoward":"double", +"nextdown":"double", +"__nextdown":"double", +"nextup":"double", +"__nextup":"double", +"remainder":[("double","(double, double)"),("float","(float, float)"),("long double","(long double, long double)")], +"__remainder":"double", +"scalbn":[("double","(double, int)"),("float","(float, int)"),("long double","(long double, int)")], +"__scalbn":"double", +"ilogb":[("int","(double)"),("int","(float)"),("int","(long double)")], +"__ilogb":"int", +"llogb":"long", +"__llogb":"long", +"scalbln":[("double","(double, long)"),("float","(float, long)"),("long double","(long double, long)")], +"__scalbln":"double", +"nearbyint":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__nearbyint":"double", +"round":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__round":"double", +"trunc":[("double","(double)"),("float","(float)"),("long double","(long double)")], +"__trunc":"double", +"remquo":[("double","(double, double, int *)"),("float","(float, float, int *)"),("long double","(long double, long double, int *)")], +"__remquo":"double", +"lrint":[("long","(double)"),("long","(float)"),("long","(long double)")], +"__lrint":"long", +"llrint":[("long long","(double)"),("long long","(float)"),("long long","(long double)")], +"__llrint":"long long", +"lround":[("long","(double)"),("long","(float)"),("long","(long double)")], +"__lround":"long", +"llround":[("long long","(double)"),("long long","(float)"),("long long","(long double)")], +"__llround":"long long", +"fdim":[("double","(double, double)"),("float","(float, float)"),("long double","(long double, long double)")], +"__fdim":"double", +"fmax":[("double","(double, double)"),("float","(float, float)"),("long double","(long double, long double)")], +"__fmax":"double", +"fmin":[("double","(double, double)"),("float","(float, float)"),("long double","(long double, long double)")], +"__fmin":"double", +"fma":[("double","(double, double, double)"),("float","(float, float, float)"),("long double","(long double, long double, long double)")], +"__fma":"double", +"roundeven":"double", +"__roundeven":"double", +"fromfp":"__intmax_t", +"__fromfp":"__intmax_t", +"ufromfp":"__uintmax_t", +"__ufromfp":"__uintmax_t", +"fromfpx":"__intmax_t", +"__fromfpx":"__intmax_t", +"ufromfpx":"__uintmax_t", +"__ufromfpx":"__uintmax_t", +"canonicalize":"int", +"fmaxmag":"double", +"__fmaxmag":"double", +"fminmag":"double", +"__fminmag":"double", +"fmaximum":"double", +"__fmaximum":"double", +"fminimum":"double", +"__fminimum":"double", +"fmaximum_num":"double", +"__fmaximum_num":"double", +"fminimum_num":"double", +"__fminimum_num":"double", +"fmaximum_mag":"double", +"__fmaximum_mag":"double", +"fminimum_mag":"double", +"__fminimum_mag":"double", +"fmaximum_mag_num":"double", +"__fmaximum_mag_num":"double", +"fminimum_mag_num":"double", +"__fminimum_mag_num":"double", +"totalorder":"int", +"totalordermag":"int", +"getpayload":"double", +"__getpayload":"double", +"setpayload":"int", +"setpayloadsig":"int", +"scalb":"double", +"__scalb":"double", +"__fpclassifyf":"int", +"__signbitf":"int", +"__isinff":"int", +"__finitef":"int", +"__isnanf":"int", +"__iseqsigf":"int", +"__issignalingf":"int", +"acosf":"float", +"__acosf":"float", +"asinf":"float", +"__asinf":"float", +"atanf":"float", +"__atanf":"float", +"atan2f":"float", +"__atan2f":"float", +"cosf":"float", +"__cosf":"float", +"sinf":"float", +"__sinf":"float", +"tanf":"float", +"__tanf":"float", +"coshf":"float", +"__coshf":"float", +"sinhf":"float", +"__sinhf":"float", +"tanhf":"float", +"__tanhf":"float", +"sincosf":"void", +"__sincosf":"void", +"acoshf":"float", +"__acoshf":"float", +"asinhf":"float", +"__asinhf":"float", +"atanhf":"float", +"__atanhf":"float", +"expf":"float", +"__expf":"float", +"frexpf":"float", +"__frexpf":"float", +"ldexpf":"float", +"__ldexpf":"float", +"logf":"float", +"__logf":"float", +"log10f":"float", +"__log10f":"float", +"modff":"float", +"__modff":"float", +"exp10f":"float", +"__exp10f":"float", +"expm1f":"float", +"__expm1f":"float", +"log1pf":"float", +"__log1pf":"float", +"logbf":"float", +"__logbf":"float", +"exp2f":"float", +"__exp2f":"float", +"log2f":"float", +"__log2f":"float", +"powf":"float", +"__powf":"float", +"sqrtf":"float", +"__sqrtf":"float", +"hypotf":"float", +"__hypotf":"float", +"cbrtf":"float", +"__cbrtf":"float", +"ceilf":"float", +"__ceilf":"float", +"fabsf":"float", +"__fabsf":"float", +"floorf":"float", +"__floorf":"float", +"fmodf":"float", +"__fmodf":"float", +"isinff":"int", +"finitef":"int", +"dremf":"float", +"__dremf":"float", +"significandf":"float", +"__significandf":"float", +"copysignf":"float", +"__copysignf":"float", +"nanf":"float", +"__nanf":"float", +"isnanf":"int", +"j0f":"float", +"__j0f":"float", +"j1f":"float", +"__j1f":"float", +"jnf":"float", +"__jnf":"float", +"y0f":"float", +"__y0f":"float", +"y1f":"float", +"__y1f":"float", +"ynf":"float", +"__ynf":"float", +"erff":"float", +"__erff":"float", +"erfcf":"float", +"__erfcf":"float", +"lgammaf":"float", +"__lgammaf":"float", +"tgammaf":"float", +"__tgammaf":"float", +"gammaf":"float", +"__gammaf":"float", +"lgammaf_r":"float", +"__lgammaf_r":"float", +"rintf":"float", +"__rintf":"float", +"nextafterf":"float", +"__nextafterf":"float", +"nexttowardf":"float", +"__nexttowardf":"float", +"nextdownf":"float", +"__nextdownf":"float", +"nextupf":"float", +"__nextupf":"float", +"remainderf":"float", +"__remainderf":"float", +"scalbnf":"float", +"__scalbnf":"float", +"ilogbf":"int", +"__ilogbf":"int", +"llogbf":"long", +"__llogbf":"long", +"scalblnf":"float", +"__scalblnf":"float", +"nearbyintf":"float", +"__nearbyintf":"float", +"roundf":"float", +"__roundf":"float", +"truncf":"float", +"__truncf":"float", +"remquof":"float", +"__remquof":"float", +"lrintf":"long", +"__lrintf":"long", +"llrintf":"long long", +"__llrintf":"long long", +"lroundf":"long", +"__lroundf":"long", +"llroundf":"long long", +"__llroundf":"long long", +"fdimf":"float", +"__fdimf":"float", +"fmaxf":"float", +"__fmaxf":"float", +"fminf":"float", +"__fminf":"float", +"fmaf":"float", +"__fmaf":"float", +"roundevenf":"float", +"__roundevenf":"float", +"fromfpf":"__intmax_t", +"__fromfpf":"__intmax_t", +"ufromfpf":"__uintmax_t", +"__ufromfpf":"__uintmax_t", +"fromfpxf":"__intmax_t", +"__fromfpxf":"__intmax_t", +"ufromfpxf":"__uintmax_t", +"__ufromfpxf":"__uintmax_t", +"canonicalizef":"int", +"fmaxmagf":"float", +"__fmaxmagf":"float", +"fminmagf":"float", +"__fminmagf":"float", +"fmaximumf":"float", +"__fmaximumf":"float", +"fminimumf":"float", +"__fminimumf":"float", +"fmaximum_numf":"float", +"__fmaximum_numf":"float", +"fminimum_numf":"float", +"__fminimum_numf":"float", +"fmaximum_magf":"float", +"__fmaximum_magf":"float", +"fminimum_magf":"float", +"__fminimum_magf":"float", +"fmaximum_mag_numf":"float", +"__fmaximum_mag_numf":"float", +"fminimum_mag_numf":"float", +"__fminimum_mag_numf":"float", +"totalorderf":"int", +"totalordermagf":"int", +"getpayloadf":"float", +"__getpayloadf":"float", +"setpayloadf":"int", +"setpayloadsigf":"int", +"scalbf":"float", +"__scalbf":"float", +"__fpclassifyl":"int", +"__signbitl":"int", +"__isinfl":"int", +"__finitel":"int", +"__isnanl":"int", +"__iseqsigl":"int", +"__issignalingl":"int", +"acosl":"long double", +"__acosl":"long double", +"asinl":"long double", +"__asinl":"long double", +"atanl":"long double", +"__atanl":"long double", +"atan2l":"long double", +"__atan2l":"long double", +"cosl":"long double", +"__cosl":"long double", +"sinl":"long double", +"__sinl":"long double", +"tanl":"long double", +"__tanl":"long double", +"coshl":"long double", +"__coshl":"long double", +"sinhl":"long double", +"__sinhl":"long double", +"tanhl":"long double", +"__tanhl":"long double", +"sincosl":"void", +"__sincosl":"void", +"acoshl":"long double", +"__acoshl":"long double", +"asinhl":"long double", +"__asinhl":"long double", +"atanhl":"long double", +"__atanhl":"long double", +"expl":"long double", +"__expl":"long double", +"frexpl":"long double", +"__frexpl":"long double", +"ldexpl":"long double", +"__ldexpl":"long double", +"logl":"long double", +"__logl":"long double", +"log10l":"long double", +"__log10l":"long double", +"modfl":"long double", +"__modfl":"long double", +"exp10l":"long double", +"__exp10l":"long double", +"expm1l":"long double", +"__expm1l":"long double", +"log1pl":"long double", +"__log1pl":"long double", +"logbl":"long double", +"__logbl":"long double", +"exp2l":"long double", +"__exp2l":"long double", +"log2l":"long double", +"__log2l":"long double", +"powl":"long double", +"__powl":"long double", +"sqrtl":"long double", +"__sqrtl":"long double", +"hypotl":"long double", +"__hypotl":"long double", +"cbrtl":"long double", +"__cbrtl":"long double", +"ceill":"long double", +"__ceill":"long double", +"fabsl":"long double", +"__fabsl":"long double", +"floorl":"long double", +"__floorl":"long double", +"fmodl":"long double", +"__fmodl":"long double", +"isinfl":"int", +"finitel":"int", +"dreml":"long double", +"__dreml":"long double", +"significandl":"long double", +"__significandl":"long double", +"copysignl":"long double", +"__copysignl":"long double", +"nanl":"long double", +"__nanl":"long double", +"isnanl":"int", +"j0l":"long double", +"__j0l":"long double", +"j1l":"long double", +"__j1l":"long double", +"jnl":"long double", +"__jnl":"long double", +"y0l":"long double", +"__y0l":"long double", +"y1l":"long double", +"__y1l":"long double", +"ynl":"long double", +"__ynl":"long double", +"erfl":"long double", +"__erfl":"long double", +"erfcl":"long double", +"__erfcl":"long double", +"lgammal":"long double", +"__lgammal":"long double", +"tgammal":"long double", +"__tgammal":"long double", +"gammal":"long double", +"__gammal":"long double", +"lgammal_r":"long double", +"__lgammal_r":"long double", +"rintl":"long double", +"__rintl":"long double", +"nextafterl":"long double", +"__nextafterl":"long double", +"nexttowardl":"long double", +"__nexttowardl":"long double", +"nextdownl":"long double", +"__nextdownl":"long double", +"nextupl":"long double", +"__nextupl":"long double", +"remainderl":"long double", +"__remainderl":"long double", +"scalbnl":"long double", +"__scalbnl":"long double", +"ilogbl":"int", +"__ilogbl":"int", +"llogbl":"long", +"__llogbl":"long", +"scalblnl":"long double", +"__scalblnl":"long double", +"nearbyintl":"long double", +"__nearbyintl":"long double", +"roundl":"long double", +"__roundl":"long double", +"truncl":"long double", +"__truncl":"long double", +"remquol":"long double", +"__remquol":"long double", +"lrintl":"long", +"__lrintl":"long", +"llrintl":"long long", +"__llrintl":"long long", +"lroundl":"long", +"__lroundl":"long", +"llroundl":"long long", +"__llroundl":"long long", +"fdiml":"long double", +"__fdiml":"long double", +"fmaxl":"long double", +"__fmaxl":"long double", +"fminl":"long double", +"__fminl":"long double", +"fmal":"long double", +"__fmal":"long double", +"roundevenl":"long double", +"__roundevenl":"long double", +"fromfpl":"__intmax_t", +"__fromfpl":"__intmax_t", +"ufromfpl":"__uintmax_t", +"__ufromfpl":"__uintmax_t", +"fromfpxl":"__intmax_t", +"__fromfpxl":"__intmax_t", +"ufromfpxl":"__uintmax_t", +"__ufromfpxl":"__uintmax_t", +"canonicalizel":"int", +"fmaxmagl":"long double", +"__fmaxmagl":"long double", +"fminmagl":"long double", +"__fminmagl":"long double", +"fmaximuml":"long double", +"__fmaximuml":"long double", +"fminimuml":"long double", +"__fminimuml":"long double", +"fmaximum_numl":"long double", +"__fmaximum_numl":"long double", +"fminimum_numl":"long double", +"__fminimum_numl":"long double", +"fmaximum_magl":"long double", +"__fmaximum_magl":"long double", +"fminimum_magl":"long double", +"__fminimum_magl":"long double", +"fmaximum_mag_numl":"long double", +"__fmaximum_mag_numl":"long double", +"fminimum_mag_numl":"long double", +"__fminimum_mag_numl":"long double", +"totalorderl":"int", +"totalordermagl":"int", +"getpayloadl":"long double", +"__getpayloadl":"long double", +"setpayloadl":"int", +"setpayloadsigl":"int", +"scalbl":"long double", +"__scalbl":"long double", +"acosf32":"_Float32", +"__acosf32":"_Float32", +"asinf32":"_Float32", +"__asinf32":"_Float32", +"atanf32":"_Float32", +"__atanf32":"_Float32", +"atan2f32":"_Float32", +"__atan2f32":"_Float32", +"cosf32":"_Float32", +"__cosf32":"_Float32", +"sinf32":"_Float32", +"__sinf32":"_Float32", +"tanf32":"_Float32", +"__tanf32":"_Float32", +"coshf32":"_Float32", +"__coshf32":"_Float32", +"sinhf32":"_Float32", +"__sinhf32":"_Float32", +"tanhf32":"_Float32", +"__tanhf32":"_Float32", +"sincosf32":"void", +"__sincosf32":"void", +"acoshf32":"_Float32", +"__acoshf32":"_Float32", +"asinhf32":"_Float32", +"__asinhf32":"_Float32", +"atanhf32":"_Float32", +"__atanhf32":"_Float32", +"expf32":"_Float32", +"__expf32":"_Float32", +"frexpf32":"_Float32", +"__frexpf32":"_Float32", +"ldexpf32":"_Float32", +"__ldexpf32":"_Float32", +"logf32":"_Float32", +"__logf32":"_Float32", +"log10f32":"_Float32", +"__log10f32":"_Float32", +"modff32":"_Float32", +"__modff32":"_Float32", +"exp10f32":"_Float32", +"__exp10f32":"_Float32", +"expm1f32":"_Float32", +"__expm1f32":"_Float32", +"log1pf32":"_Float32", +"__log1pf32":"_Float32", +"logbf32":"_Float32", +"__logbf32":"_Float32", +"exp2f32":"_Float32", +"__exp2f32":"_Float32", +"log2f32":"_Float32", +"__log2f32":"_Float32", +"powf32":"_Float32", +"__powf32":"_Float32", +"sqrtf32":"_Float32", +"__sqrtf32":"_Float32", +"hypotf32":"_Float32", +"__hypotf32":"_Float32", +"cbrtf32":"_Float32", +"__cbrtf32":"_Float32", +"ceilf32":"_Float32", +"__ceilf32":"_Float32", +"fabsf32":"_Float32", +"__fabsf32":"_Float32", +"floorf32":"_Float32", +"__floorf32":"_Float32", +"fmodf32":"_Float32", +"__fmodf32":"_Float32", +"copysignf32":"_Float32", +"__copysignf32":"_Float32", +"nanf32":"_Float32", +"__nanf32":"_Float32", +"j0f32":"_Float32", +"__j0f32":"_Float32", +"j1f32":"_Float32", +"__j1f32":"_Float32", +"jnf32":"_Float32", +"__jnf32":"_Float32", +"y0f32":"_Float32", +"__y0f32":"_Float32", +"y1f32":"_Float32", +"__y1f32":"_Float32", +"ynf32":"_Float32", +"__ynf32":"_Float32", +"erff32":"_Float32", +"__erff32":"_Float32", +"erfcf32":"_Float32", +"__erfcf32":"_Float32", +"lgammaf32":"_Float32", +"__lgammaf32":"_Float32", +"tgammaf32":"_Float32", +"__tgammaf32":"_Float32", +"lgammaf32_r":"_Float32", +"__lgammaf32_r":"_Float32", +"rintf32":"_Float32", +"__rintf32":"_Float32", +"nextafterf32":"_Float32", +"__nextafterf32":"_Float32", +"nextdownf32":"_Float32", +"__nextdownf32":"_Float32", +"nextupf32":"_Float32", +"__nextupf32":"_Float32", +"remainderf32":"_Float32", +"__remainderf32":"_Float32", +"scalbnf32":"_Float32", +"__scalbnf32":"_Float32", +"ilogbf32":"int", +"__ilogbf32":"int", +"llogbf32":"long", +"__llogbf32":"long", +"scalblnf32":"_Float32", +"__scalblnf32":"_Float32", +"nearbyintf32":"_Float32", +"__nearbyintf32":"_Float32", +"roundf32":"_Float32", +"__roundf32":"_Float32", +"truncf32":"_Float32", +"__truncf32":"_Float32", +"remquof32":"_Float32", +"__remquof32":"_Float32", +"lrintf32":"long", +"__lrintf32":"long", +"llrintf32":"long long", +"__llrintf32":"long long", +"lroundf32":"long", +"__lroundf32":"long", +"llroundf32":"long long", +"__llroundf32":"long long", +"fdimf32":"_Float32", +"__fdimf32":"_Float32", +"fmaxf32":"_Float32", +"__fmaxf32":"_Float32", +"fminf32":"_Float32", +"__fminf32":"_Float32", +"fmaf32":"_Float32", +"__fmaf32":"_Float32", +"roundevenf32":"_Float32", +"__roundevenf32":"_Float32", +"fromfpf32":"__intmax_t", +"__fromfpf32":"__intmax_t", +"ufromfpf32":"__uintmax_t", +"__ufromfpf32":"__uintmax_t", +"fromfpxf32":"__intmax_t", +"__fromfpxf32":"__intmax_t", +"ufromfpxf32":"__uintmax_t", +"__ufromfpxf32":"__uintmax_t", +"canonicalizef32":"int", +"fmaxmagf32":"_Float32", +"__fmaxmagf32":"_Float32", +"fminmagf32":"_Float32", +"__fminmagf32":"_Float32", +"fmaximumf32":"_Float32", +"__fmaximumf32":"_Float32", +"fminimumf32":"_Float32", +"__fminimumf32":"_Float32", +"fmaximum_numf32":"_Float32", +"__fmaximum_numf32":"_Float32", +"fminimum_numf32":"_Float32", +"__fminimum_numf32":"_Float32", +"fmaximum_magf32":"_Float32", +"__fmaximum_magf32":"_Float32", +"fminimum_magf32":"_Float32", +"__fminimum_magf32":"_Float32", +"fmaximum_mag_numf32":"_Float32", +"__fmaximum_mag_numf32":"_Float32", +"fminimum_mag_numf32":"_Float32", +"__fminimum_mag_numf32":"_Float32", +"totalorderf32":"int", +"totalordermagf32":"int", +"getpayloadf32":"_Float32", +"__getpayloadf32":"_Float32", +"setpayloadf32":"int", +"setpayloadsigf32":"int", +"acosf64":"_Float64", +"__acosf64":"_Float64", +"asinf64":"_Float64", +"__asinf64":"_Float64", +"atanf64":"_Float64", +"__atanf64":"_Float64", +"atan2f64":"_Float64", +"__atan2f64":"_Float64", +"cosf64":"_Float64", +"__cosf64":"_Float64", +"sinf64":"_Float64", +"__sinf64":"_Float64", +"tanf64":"_Float64", +"__tanf64":"_Float64", +"coshf64":"_Float64", +"__coshf64":"_Float64", +"sinhf64":"_Float64", +"__sinhf64":"_Float64", +"tanhf64":"_Float64", +"__tanhf64":"_Float64", +"sincosf64":"void", +"__sincosf64":"void", +"acoshf64":"_Float64", +"__acoshf64":"_Float64", +"asinhf64":"_Float64", +"__asinhf64":"_Float64", +"atanhf64":"_Float64", +"__atanhf64":"_Float64", +"expf64":"_Float64", +"__expf64":"_Float64", +"frexpf64":"_Float64", +"__frexpf64":"_Float64", +"ldexpf64":"_Float64", +"__ldexpf64":"_Float64", +"logf64":"_Float64", +"__logf64":"_Float64", +"log10f64":"_Float64", +"__log10f64":"_Float64", +"modff64":"_Float64", +"__modff64":"_Float64", +"exp10f64":"_Float64", +"__exp10f64":"_Float64", +"expm1f64":"_Float64", +"__expm1f64":"_Float64", +"log1pf64":"_Float64", +"__log1pf64":"_Float64", +"logbf64":"_Float64", +"__logbf64":"_Float64", +"exp2f64":"_Float64", +"__exp2f64":"_Float64", +"log2f64":"_Float64", +"__log2f64":"_Float64", +"powf64":"_Float64", +"__powf64":"_Float64", +"sqrtf64":"_Float64", +"__sqrtf64":"_Float64", +"hypotf64":"_Float64", +"__hypotf64":"_Float64", +"cbrtf64":"_Float64", +"__cbrtf64":"_Float64", +"ceilf64":"_Float64", +"__ceilf64":"_Float64", +"fabsf64":"_Float64", +"__fabsf64":"_Float64", +"floorf64":"_Float64", +"__floorf64":"_Float64", +"fmodf64":"_Float64", +"__fmodf64":"_Float64", +"copysignf64":"_Float64", +"__copysignf64":"_Float64", +"nanf64":"_Float64", +"__nanf64":"_Float64", +"j0f64":"_Float64", +"__j0f64":"_Float64", +"j1f64":"_Float64", +"__j1f64":"_Float64", +"jnf64":"_Float64", +"__jnf64":"_Float64", +"y0f64":"_Float64", +"__y0f64":"_Float64", +"y1f64":"_Float64", +"__y1f64":"_Float64", +"ynf64":"_Float64", +"__ynf64":"_Float64", +"erff64":"_Float64", +"__erff64":"_Float64", +"erfcf64":"_Float64", +"__erfcf64":"_Float64", +"lgammaf64":"_Float64", +"__lgammaf64":"_Float64", +"tgammaf64":"_Float64", +"__tgammaf64":"_Float64", +"lgammaf64_r":"_Float64", +"__lgammaf64_r":"_Float64", +"rintf64":"_Float64", +"__rintf64":"_Float64", +"nextafterf64":"_Float64", +"__nextafterf64":"_Float64", +"nextdownf64":"_Float64", +"__nextdownf64":"_Float64", +"nextupf64":"_Float64", +"__nextupf64":"_Float64", +"remainderf64":"_Float64", +"__remainderf64":"_Float64", +"scalbnf64":"_Float64", +"__scalbnf64":"_Float64", +"ilogbf64":"int", +"__ilogbf64":"int", +"llogbf64":"long", +"__llogbf64":"long", +"scalblnf64":"_Float64", +"__scalblnf64":"_Float64", +"nearbyintf64":"_Float64", +"__nearbyintf64":"_Float64", +"roundf64":"_Float64", +"__roundf64":"_Float64", +"truncf64":"_Float64", +"__truncf64":"_Float64", +"remquof64":"_Float64", +"__remquof64":"_Float64", +"lrintf64":"long", +"__lrintf64":"long", +"llrintf64":"long long", +"__llrintf64":"long long", +"lroundf64":"long", +"__lroundf64":"long", +"llroundf64":"long long", +"__llroundf64":"long long", +"fdimf64":"_Float64", +"__fdimf64":"_Float64", +"fmaxf64":"_Float64", +"__fmaxf64":"_Float64", +"fminf64":"_Float64", +"__fminf64":"_Float64", +"fmaf64":"_Float64", +"__fmaf64":"_Float64", +"roundevenf64":"_Float64", +"__roundevenf64":"_Float64", +"fromfpf64":"__intmax_t", +"__fromfpf64":"__intmax_t", +"ufromfpf64":"__uintmax_t", +"__ufromfpf64":"__uintmax_t", +"fromfpxf64":"__intmax_t", +"__fromfpxf64":"__intmax_t", +"ufromfpxf64":"__uintmax_t", +"__ufromfpxf64":"__uintmax_t", +"canonicalizef64":"int", +"fmaxmagf64":"_Float64", +"__fmaxmagf64":"_Float64", +"fminmagf64":"_Float64", +"__fminmagf64":"_Float64", +"fmaximumf64":"_Float64", +"__fmaximumf64":"_Float64", +"fminimumf64":"_Float64", +"__fminimumf64":"_Float64", +"fmaximum_numf64":"_Float64", +"__fmaximum_numf64":"_Float64", +"fminimum_numf64":"_Float64", +"__fminimum_numf64":"_Float64", +"fmaximum_magf64":"_Float64", +"__fmaximum_magf64":"_Float64", +"fminimum_magf64":"_Float64", +"__fminimum_magf64":"_Float64", +"fmaximum_mag_numf64":"_Float64", +"__fmaximum_mag_numf64":"_Float64", +"fminimum_mag_numf64":"_Float64", +"__fminimum_mag_numf64":"_Float64", +"totalorderf64":"int", +"totalordermagf64":"int", +"getpayloadf64":"_Float64", +"__getpayloadf64":"_Float64", +"setpayloadf64":"int", +"setpayloadsigf64":"int", +"acosf32x":"_Float32x", +"__acosf32x":"_Float32x", +"asinf32x":"_Float32x", +"__asinf32x":"_Float32x", +"atanf32x":"_Float32x", +"__atanf32x":"_Float32x", +"atan2f32x":"_Float32x", +"__atan2f32x":"_Float32x", +"cosf32x":"_Float32x", +"__cosf32x":"_Float32x", +"sinf32x":"_Float32x", +"__sinf32x":"_Float32x", +"tanf32x":"_Float32x", +"__tanf32x":"_Float32x", +"coshf32x":"_Float32x", +"__coshf32x":"_Float32x", +"sinhf32x":"_Float32x", +"__sinhf32x":"_Float32x", +"tanhf32x":"_Float32x", +"__tanhf32x":"_Float32x", +"sincosf32x":"void", +"__sincosf32x":"void", +"acoshf32x":"_Float32x", +"__acoshf32x":"_Float32x", +"asinhf32x":"_Float32x", +"__asinhf32x":"_Float32x", +"atanhf32x":"_Float32x", +"__atanhf32x":"_Float32x", +"expf32x":"_Float32x", +"__expf32x":"_Float32x", +"frexpf32x":"_Float32x", +"__frexpf32x":"_Float32x", +"ldexpf32x":"_Float32x", +"__ldexpf32x":"_Float32x", +"logf32x":"_Float32x", +"__logf32x":"_Float32x", +"log10f32x":"_Float32x", +"__log10f32x":"_Float32x", +"modff32x":"_Float32x", +"__modff32x":"_Float32x", +"exp10f32x":"_Float32x", +"__exp10f32x":"_Float32x", +"expm1f32x":"_Float32x", +"__expm1f32x":"_Float32x", +"log1pf32x":"_Float32x", +"__log1pf32x":"_Float32x", +"logbf32x":"_Float32x", +"__logbf32x":"_Float32x", +"exp2f32x":"_Float32x", +"__exp2f32x":"_Float32x", +"log2f32x":"_Float32x", +"__log2f32x":"_Float32x", +"powf32x":"_Float32x", +"__powf32x":"_Float32x", +"sqrtf32x":"_Float32x", +"__sqrtf32x":"_Float32x", +"hypotf32x":"_Float32x", +"__hypotf32x":"_Float32x", +"cbrtf32x":"_Float32x", +"__cbrtf32x":"_Float32x", +"ceilf32x":"_Float32x", +"__ceilf32x":"_Float32x", +"fabsf32x":"_Float32x", +"__fabsf32x":"_Float32x", +"floorf32x":"_Float32x", +"__floorf32x":"_Float32x", +"fmodf32x":"_Float32x", +"__fmodf32x":"_Float32x", +"copysignf32x":"_Float32x", +"__copysignf32x":"_Float32x", +"nanf32x":"_Float32x", +"__nanf32x":"_Float32x", +"j0f32x":"_Float32x", +"__j0f32x":"_Float32x", +"j1f32x":"_Float32x", +"__j1f32x":"_Float32x", +"jnf32x":"_Float32x", +"__jnf32x":"_Float32x", +"y0f32x":"_Float32x", +"__y0f32x":"_Float32x", +"y1f32x":"_Float32x", +"__y1f32x":"_Float32x", +"ynf32x":"_Float32x", +"__ynf32x":"_Float32x", +"erff32x":"_Float32x", +"__erff32x":"_Float32x", +"erfcf32x":"_Float32x", +"__erfcf32x":"_Float32x", +"lgammaf32x":"_Float32x", +"__lgammaf32x":"_Float32x", +"tgammaf32x":"_Float32x", +"__tgammaf32x":"_Float32x", +"lgammaf32x_r":"_Float32x", +"__lgammaf32x_r":"_Float32x", +"rintf32x":"_Float32x", +"__rintf32x":"_Float32x", +"nextafterf32x":"_Float32x", +"__nextafterf32x":"_Float32x", +"nextdownf32x":"_Float32x", +"__nextdownf32x":"_Float32x", +"nextupf32x":"_Float32x", +"__nextupf32x":"_Float32x", +"remainderf32x":"_Float32x", +"__remainderf32x":"_Float32x", +"scalbnf32x":"_Float32x", +"__scalbnf32x":"_Float32x", +"ilogbf32x":"int", +"__ilogbf32x":"int", +"llogbf32x":"long", +"__llogbf32x":"long", +"scalblnf32x":"_Float32x", +"__scalblnf32x":"_Float32x", +"nearbyintf32x":"_Float32x", +"__nearbyintf32x":"_Float32x", +"roundf32x":"_Float32x", +"__roundf32x":"_Float32x", +"truncf32x":"_Float32x", +"__truncf32x":"_Float32x", +"remquof32x":"_Float32x", +"__remquof32x":"_Float32x", +"lrintf32x":"long", +"__lrintf32x":"long", +"llrintf32x":"long long", +"__llrintf32x":"long long", +"lroundf32x":"long", +"__lroundf32x":"long", +"llroundf32x":"long long", +"__llroundf32x":"long long", +"fdimf32x":"_Float32x", +"__fdimf32x":"_Float32x", +"fmaxf32x":"_Float32x", +"__fmaxf32x":"_Float32x", +"fminf32x":"_Float32x", +"__fminf32x":"_Float32x", +"fmaf32x":"_Float32x", +"__fmaf32x":"_Float32x", +"roundevenf32x":"_Float32x", +"__roundevenf32x":"_Float32x", +"fromfpf32x":"__intmax_t", +"__fromfpf32x":"__intmax_t", +"ufromfpf32x":"__uintmax_t", +"__ufromfpf32x":"__uintmax_t", +"fromfpxf32x":"__intmax_t", +"__fromfpxf32x":"__intmax_t", +"ufromfpxf32x":"__uintmax_t", +"__ufromfpxf32x":"__uintmax_t", +"canonicalizef32x":"int", +"fmaxmagf32x":"_Float32x", +"__fmaxmagf32x":"_Float32x", +"fminmagf32x":"_Float32x", +"__fminmagf32x":"_Float32x", +"fmaximumf32x":"_Float32x", +"__fmaximumf32x":"_Float32x", +"fminimumf32x":"_Float32x", +"__fminimumf32x":"_Float32x", +"fmaximum_numf32x":"_Float32x", +"__fmaximum_numf32x":"_Float32x", +"fminimum_numf32x":"_Float32x", +"__fminimum_numf32x":"_Float32x", +"fmaximum_magf32x":"_Float32x", +"__fmaximum_magf32x":"_Float32x", +"fminimum_magf32x":"_Float32x", +"__fminimum_magf32x":"_Float32x", +"fmaximum_mag_numf32x":"_Float32x", +"__fmaximum_mag_numf32x":"_Float32x", +"fminimum_mag_numf32x":"_Float32x", +"__fminimum_mag_numf32x":"_Float32x", +"totalorderf32x":"int", +"totalordermagf32x":"int", +"getpayloadf32x":"_Float32x", +"__getpayloadf32x":"_Float32x", +"setpayloadf32x":"int", +"setpayloadsigf32x":"int", +"acosf64x":"_Float64x", +"__acosf64x":"_Float64x", +"asinf64x":"_Float64x", +"__asinf64x":"_Float64x", +"atanf64x":"_Float64x", +"__atanf64x":"_Float64x", +"atan2f64x":"_Float64x", +"__atan2f64x":"_Float64x", +"cosf64x":"_Float64x", +"__cosf64x":"_Float64x", +"sinf64x":"_Float64x", +"__sinf64x":"_Float64x", +"tanf64x":"_Float64x", +"__tanf64x":"_Float64x", +"coshf64x":"_Float64x", +"__coshf64x":"_Float64x", +"sinhf64x":"_Float64x", +"__sinhf64x":"_Float64x", +"tanhf64x":"_Float64x", +"__tanhf64x":"_Float64x", +"sincosf64x":"void", +"__sincosf64x":"void", +"acoshf64x":"_Float64x", +"__acoshf64x":"_Float64x", +"asinhf64x":"_Float64x", +"__asinhf64x":"_Float64x", +"atanhf64x":"_Float64x", +"__atanhf64x":"_Float64x", +"expf64x":"_Float64x", +"__expf64x":"_Float64x", +"frexpf64x":"_Float64x", +"__frexpf64x":"_Float64x", +"ldexpf64x":"_Float64x", +"__ldexpf64x":"_Float64x", +"logf64x":"_Float64x", +"__logf64x":"_Float64x", +"log10f64x":"_Float64x", +"__log10f64x":"_Float64x", +"modff64x":"_Float64x", +"__modff64x":"_Float64x", +"exp10f64x":"_Float64x", +"__exp10f64x":"_Float64x", +"expm1f64x":"_Float64x", +"__expm1f64x":"_Float64x", +"log1pf64x":"_Float64x", +"__log1pf64x":"_Float64x", +"logbf64x":"_Float64x", +"__logbf64x":"_Float64x", +"exp2f64x":"_Float64x", +"__exp2f64x":"_Float64x", +"log2f64x":"_Float64x", +"__log2f64x":"_Float64x", +"powf64x":"_Float64x", +"__powf64x":"_Float64x", +"sqrtf64x":"_Float64x", +"__sqrtf64x":"_Float64x", +"hypotf64x":"_Float64x", +"__hypotf64x":"_Float64x", +"cbrtf64x":"_Float64x", +"__cbrtf64x":"_Float64x", +"ceilf64x":"_Float64x", +"__ceilf64x":"_Float64x", +"fabsf64x":"_Float64x", +"__fabsf64x":"_Float64x", +"floorf64x":"_Float64x", +"__floorf64x":"_Float64x", +"fmodf64x":"_Float64x", +"__fmodf64x":"_Float64x", +"copysignf64x":"_Float64x", +"__copysignf64x":"_Float64x", +"nanf64x":"_Float64x", +"__nanf64x":"_Float64x", +"j0f64x":"_Float64x", +"__j0f64x":"_Float64x", +"j1f64x":"_Float64x", +"__j1f64x":"_Float64x", +"jnf64x":"_Float64x", +"__jnf64x":"_Float64x", +"y0f64x":"_Float64x", +"__y0f64x":"_Float64x", +"y1f64x":"_Float64x", +"__y1f64x":"_Float64x", +"ynf64x":"_Float64x", +"__ynf64x":"_Float64x", +"erff64x":"_Float64x", +"__erff64x":"_Float64x", +"erfcf64x":"_Float64x", +"__erfcf64x":"_Float64x", +"lgammaf64x":"_Float64x", +"__lgammaf64x":"_Float64x", +"tgammaf64x":"_Float64x", +"__tgammaf64x":"_Float64x", +"lgammaf64x_r":"_Float64x", +"__lgammaf64x_r":"_Float64x", +"rintf64x":"_Float64x", +"__rintf64x":"_Float64x", +"nextafterf64x":"_Float64x", +"__nextafterf64x":"_Float64x", +"nextdownf64x":"_Float64x", +"__nextdownf64x":"_Float64x", +"nextupf64x":"_Float64x", +"__nextupf64x":"_Float64x", +"remainderf64x":"_Float64x", +"__remainderf64x":"_Float64x", +"scalbnf64x":"_Float64x", +"__scalbnf64x":"_Float64x", +"ilogbf64x":"int", +"__ilogbf64x":"int", +"llogbf64x":"long", +"__llogbf64x":"long", +"scalblnf64x":"_Float64x", +"__scalblnf64x":"_Float64x", +"nearbyintf64x":"_Float64x", +"__nearbyintf64x":"_Float64x", +"roundf64x":"_Float64x", +"__roundf64x":"_Float64x", +"truncf64x":"_Float64x", +"__truncf64x":"_Float64x", +"remquof64x":"_Float64x", +"__remquof64x":"_Float64x", +"lrintf64x":"long", +"__lrintf64x":"long", +"llrintf64x":"long long", +"__llrintf64x":"long long", +"lroundf64x":"long", +"__lroundf64x":"long", +"llroundf64x":"long long", +"__llroundf64x":"long long", +"fdimf64x":"_Float64x", +"__fdimf64x":"_Float64x", +"fmaxf64x":"_Float64x", +"__fmaxf64x":"_Float64x", +"fminf64x":"_Float64x", +"__fminf64x":"_Float64x", +"fmaf64x":"_Float64x", +"__fmaf64x":"_Float64x", +"roundevenf64x":"_Float64x", +"__roundevenf64x":"_Float64x", +"fromfpf64x":"__intmax_t", +"__fromfpf64x":"__intmax_t", +"ufromfpf64x":"__uintmax_t", +"__ufromfpf64x":"__uintmax_t", +"fromfpxf64x":"__intmax_t", +"__fromfpxf64x":"__intmax_t", +"ufromfpxf64x":"__uintmax_t", +"__ufromfpxf64x":"__uintmax_t", +"canonicalizef64x":"int", +"fmaxmagf64x":"_Float64x", +"__fmaxmagf64x":"_Float64x", +"fminmagf64x":"_Float64x", +"__fminmagf64x":"_Float64x", +"fmaximumf64x":"_Float64x", +"__fmaximumf64x":"_Float64x", +"fminimumf64x":"_Float64x", +"__fminimumf64x":"_Float64x", +"fmaximum_numf64x":"_Float64x", +"__fmaximum_numf64x":"_Float64x", +"fminimum_numf64x":"_Float64x", +"__fminimum_numf64x":"_Float64x", +"fmaximum_magf64x":"_Float64x", +"__fmaximum_magf64x":"_Float64x", +"fminimum_magf64x":"_Float64x", +"__fminimum_magf64x":"_Float64x", +"fmaximum_mag_numf64x":"_Float64x", +"__fmaximum_mag_numf64x":"_Float64x", +"fminimum_mag_numf64x":"_Float64x", +"__fminimum_mag_numf64x":"_Float64x", +"totalorderf64x":"int", +"totalordermagf64x":"int", +"getpayloadf64x":"_Float64x", +"__getpayloadf64x":"_Float64x", +"setpayloadf64x":"int", +"setpayloadsigf64x":"int", +"fadd":"float", +"fdiv":"float", +"ffma":"float", +"fmul":"float", +"fsqrt":"float", +"fsub":"float", +"faddl":"float", +"fdivl":"float", +"ffmal":"float", +"fmull":"float", +"fsqrtl":"float", +"fsubl":"float", +"daddl":"double", +"ddivl":"double", +"dfmal":"double", +"dmull":"double", +"dsqrtl":"double", +"dsubl":"double", +"f32addf32x":"_Float32", +"f32divf32x":"_Float32", +"f32fmaf32x":"_Float32", +"f32mulf32x":"_Float32", +"f32sqrtf32x":"_Float32", +"f32subf32x":"_Float32", +"f32addf64":"_Float32", +"f32divf64":"_Float32", +"f32fmaf64":"_Float32", +"f32mulf64":"_Float32", +"f32sqrtf64":"_Float32", +"f32subf64":"_Float32", +"f32addf64x":"_Float32", +"f32divf64x":"_Float32", +"f32fmaf64x":"_Float32", +"f32mulf64x":"_Float32", +"f32sqrtf64x":"_Float32", +"f32subf64x":"_Float32", +"f32xaddf64":"_Float32x", +"f32xdivf64":"_Float32x", +"f32xfmaf64":"_Float32x", +"f32xmulf64":"_Float32x", +"f32xsqrtf64":"_Float32x", +"f32xsubf64":"_Float32x", +"f32xaddf64x":"_Float32x", +"f32xdivf64x":"_Float32x", +"f32xfmaf64x":"_Float32x", +"f32xmulf64x":"_Float32x", +"f32xsqrtf64x":"_Float32x", +"f32xsubf64x":"_Float32x", +"f64addf64x":"_Float64", +"f64divf64x":"_Float64", +"f64fmaf64x":"_Float64", +"f64mulf64x":"_Float64", +"f64sqrtf64x":"_Float64", +"f64subf64x":"_Float64", +"__iscanonicall":"int", +"iscanonical":[("int","(float)"),("int","(double)"),("int","(long double)")], +"issignaling":[("int","(float)"),("int","(double)"),("int","(long double)")], +"__ctype_get_mb_cur_max":"size_t", +"atof":"double", +"atoi":"int", +"atol":"long", +"atoll":"long long", +"strtod":"double", +"strtof":"float", +"strtold":"long double", +"strtof32":"_Float32", +"strtof64":"_Float64", +"strtof32x":"_Float32x", +"strtof64x":"_Float64x", +"strtol":"long", +"strtoul":"unsigned long", +"strtoq":"long long", +"strtouq":"unsigned long long", +"strtoll":"long long", +"strtoull":"unsigned long long", +"strfromd":"int", +"strfromf":"int", +"strfroml":"int", +"strfromf32":"int", +"strfromf64":"int", +"strfromf32x":"int", +"strfromf64x":"int", +"strtol_l":"long", +"strtoul_l":"unsigned long", +"strtoll_l":"long long", +"strtoull_l":"unsigned long long", +"strtod_l":"double", +"strtof_l":"float", +"strtold_l":"long double", +"strtof32_l":"_Float32", +"strtof64_l":"_Float64", +"strtof32x_l":"_Float32x", +"strtof64x_l":"_Float64x", +"l64a":"char *", +"a64l":"long", +"__bswap_16":"__uint16_t", +"__bswap_32":"__uint32_t", +"__bswap_64":"__uint64_t", +"__uint16_identity":"__uint16_t", +"__uint32_identity":"__uint32_t", +"__uint64_identity":"__uint64_t", +"select":"int", +"pselect":"int", +"random":"long", +"srandom":"void", +"initstate":"char *", +"setstate":"char *", +"random_r":"int", +"srandom_r":"int", +"initstate_r":"int", +"setstate_r":"int", +"rand":"int", +"srand":"void", +"rand_r":"int", +"drand48":"double", +"erand48":"double", +"lrand48":"long", +"nrand48":"long", +"mrand48":"long", +"jrand48":"long", +"srand48":"void", +"seed48":"unsigned short *", +"lcong48":"void", +"drand48_r":"int", +"erand48_r":"int", +"lrand48_r":"int", +"nrand48_r":"int", +"mrand48_r":"int", +"jrand48_r":"int", +"srand48_r":"int", +"seed48_r":"int", +"lcong48_r":"int", +"malloc":"void *", +"calloc":"void *", +"realloc":"void *", +"free":"void", +"reallocarray":[("void *","(void *, size_t, size_t)"),("void *","(void *, size_t, size_t)")], +"alloca":"void *", +"valloc":"void *", +"posix_memalign":"int", +"aligned_alloc":"void *", +"abort":"void", +"atexit":"int", +"at_quick_exit":"int", +"on_exit":"int", +"exit":"void", +"quick_exit":"void", +"_Exit":"void", +"getenv":"char *", +"secure_getenv":"char *", +"putenv":"int", +"setenv":"int", +"unsetenv":"int", +"clearenv":"int", +"mktemp":"char *", +"mkstemp":"int", +"mkstemp64":"int", +"mkstemps":"int", +"mkstemps64":"int", +"mkdtemp":"char *", +"mkostemp":"int", +"mkostemp64":"int", +"mkostemps":"int", +"mkostemps64":"int", +"system":"int", +"canonicalize_file_name":"char *", +"realpath":"char *", +"bsearch":"void *", +"qsort":"void", +"qsort_r":"void", +"abs":[("int","(int)"),("long","(long)"),("long long","(long long)"),("double","(double)"),("float","(float)"),("long double","(long double)"),("__int128","(__int128)"),("__float128","(__float128)")], +"labs":"long", +"llabs":"long long", +"div":[("div_t","(int, int)"),("ldiv_t","(long, long)"),("lldiv_t","(long long, long long)")], +"ldiv":"ldiv_t", +"lldiv":"lldiv_t", +"ecvt":"char *", +"fcvt":"char *", +"gcvt":"char *", +"qecvt":"char *", +"qfcvt":"char *", +"qgcvt":"char *", +"ecvt_r":"int", +"fcvt_r":"int", +"qecvt_r":"int", +"qfcvt_r":"int", +"mblen":"int", +"mbtowc":"int", +"wctomb":"int", +"mbstowcs":"size_t", +"wcstombs":"size_t", +"rpmatch":"int", +"getsubopt":"int", +"posix_openpt":"int", +"grantpt":"int", +"unlockpt":"int", +"ptsname":"char *", +"ptsname_r":"int", +"getpt":"int", +"getloadavg":"int", +"fpclassify":[("int","(float)"),("int","(double)"),("int","(long double)")], +"isfinite":[("bool","(float)"),("bool","(double)"),("bool","(long double)")], +"isinf":[("bool","(float)"),("bool","(double)"),("bool","(long double)")], +"isnan":[("bool","(float)"),("bool","(double)"),("bool","(long double)")], +"isnormal":[("bool","(float)"),("bool","(double)"),("bool","(long double)")], +"signbit":[("bool","(float)"),("bool","(double)"),("bool","(long double)")], +"isgreater":[("bool","(float, float)"),("bool","(double, double)"),("bool","(long double, long double)")], +"isgreaterequal":[("bool","(float, float)"),("bool","(double, double)"),("bool","(long double, long double)")], +"isless":[("bool","(float, float)"),("bool","(double, double)"),("bool","(long double, long double)")], +"islessequal":[("bool","(float, float)"),("bool","(double, double)"),("bool","(long double, long double)")], +"islessgreater":[("bool","(float, float)"),("bool","(double, double)"),("bool","(long double, long double)")], +"isunordered":[("bool","(float, float)"),("bool","(double, double)"),("bool","(long double, long double)")], +"setjmp":"int", +"__sigsetjmp":[("int","(struct __jmp_buf_tag *, int)"),("int","(struct __jmp_buf_tag *, int)")], +"_setjmp":"int", +"longjmp":"void", +"_longjmp":"void", +"siglongjmp":"void", +"__sysv_signal":"__sighandler_t", +"sysv_signal":"__sighandler_t", +"signal":"__sighandler_t", +"kill":"int", +"killpg":"int", +"raise":"int", +"ssignal":"__sighandler_t", +"gsignal":"int", +"psignal":"void", +"psiginfo":"void", +"sigpause":"int", +"sigblock":"int", +"sigsetmask":"int", +"siggetmask":"int", +"sigemptyset":"int", +"sigfillset":"int", +"sigaddset":"int", +"sigdelset":"int", +"sigismember":"int", +"sigisemptyset":"int", +"sigandset":"int", +"sigorset":"int", +"sigprocmask":"int", +"sigsuspend":"int", +"sigaction":"int", +"sigpending":"int", +"sigwait":"int", +"sigwaitinfo":"int", +"sigtimedwait":"int", +"sigqueue":"int", +"sigreturn":"int", +"siginterrupt":"int", +"access":"int", +"euidaccess":"int", +"eaccess":"int", +"execveat":"int", +"faccessat":"int", +"lseek":"__off_t", +"lseek64":"__off64_t", +"close":"int", +"closefrom":"void", +"read":"ssize_t", +"write":"ssize_t", +"pread":"ssize_t", +"pwrite":"ssize_t", +"pread64":"ssize_t", +"pwrite64":"ssize_t", +"pipe":"int", +"pipe2":"int", +"alarm":"unsigned int", +"sleep":"unsigned int", +"ualarm":"__useconds_t", +"usleep":"int", +"pause":"int", +"chown":"int", +"fchown":"int", +"lchown":"int", +"fchownat":"int", +"chdir":"int", +"fchdir":"int", +"getcwd":"char *", +"get_current_dir_name":"char *", +"getwd":"char *", +"dup":"int", +"dup2":"int", +"dup3":"int", +"execve":"int", +"fexecve":"int", +"execv":"int", +"execle":"int", +"execl":"int", +"execvp":"int", +"execlp":"int", +"execvpe":"int", +"nice":"int", +"_exit":"void", +"pathconf":"long", +"fpathconf":"long", +"sysconf":"long", +"confstr":"size_t", +"getpid":"__pid_t", +"getppid":"__pid_t", +"getpgrp":"__pid_t", +"__getpgid":"__pid_t", +"getpgid":"__pid_t", +"setpgid":"int", +"setpgrp":"int", +"setsid":"__pid_t", +"getsid":"__pid_t", +"getuid":"__uid_t", +"geteuid":"__uid_t", +"getgid":"__gid_t", +"getegid":"__gid_t", +"getgroups":"int", +"group_member":"int", +"setuid":"int", +"setreuid":"int", +"seteuid":"int", +"setgid":"int", +"setregid":"int", +"setegid":"int", +"getresuid":"int", +"getresgid":"int", +"setresuid":"int", +"setresgid":"int", +"fork":"__pid_t", +"vfork":"__pid_t", +"_Fork":"__pid_t", +"ttyname":"char *", +"ttyname_r":"int", +"isatty":"int", +"ttyslot":"int", +"link":"int", +"linkat":"int", +"symlink":"int", +"readlink":"ssize_t", +"symlinkat":"int", +"readlinkat":"ssize_t", +"unlink":"int", +"unlinkat":"int", +"rmdir":"int", +"tcgetpgrp":"__pid_t", +"tcsetpgrp":"int", +"getlogin":"char *", +"getlogin_r":"int", +"setlogin":"int", +"getopt":"int", +"gethostname":"int", +"sethostname":"int", +"sethostid":"int", +"getdomainname":"int", +"setdomainname":"int", +"vhangup":"int", +"revoke":"int", +"profil":"int", +"acct":"int", +"getusershell":"char *", +"endusershell":"void", +"setusershell":"void", +"daemon":"int", +"chroot":"int", +"getpass":"char *", +"fsync":"int", +"syncfs":"int", +"gethostid":"long", +"sync":"void", +"getpagesize":"int", +"getdtablesize":"int", +"truncate":"int", +"truncate64":"int", +"ftruncate":"int", +"ftruncate64":"int", +"brk":"int", +"sbrk":"void *", +"syscall":"long", +"lockf":"int", +"lockf64":"int", +"copy_file_range":"ssize_t", +"fdatasync":"int", +"crypt":"char *", +"swab":"void", +"getentropy":"int", +"close_range":"int", +"gettid":"__pid_t", +"sigaltstack":"int", +"sigstack":"int", +"sighold":"int", +"sigrelse":"int", +"sigignore":"int", +"sigset":"__sighandler_t", +"pthread_sigmask":"int", +"pthread_kill":"int", +"pthread_sigqueue":"int", +"__libc_current_sigrtmin":"int", +"__libc_current_sigrtmax":"int", +"tgkill":"int", +"remove":"int", +"rename":"int", +"renameat":"int", +"renameat2":"int", +"fclose":"int", +"tmpfile":"FILE *", +"tmpfile64":"FILE *", +"tmpnam":"char *", +"tmpnam_r":"char *", +"tempnam":"char *", +"fflush":"int", +"fflush_unlocked":"int", +"fcloseall":"int", +"fopen":"FILE *", +"freopen":"FILE *", +"fopen64":"FILE *", +"freopen64":"FILE *", +"fdopen":"FILE *", +"fopencookie":"FILE *", +"fmemopen":"FILE *", +"open_memstream":"FILE *", +"setbuf":"void", +"setvbuf":"int", +"setbuffer":"void", +"setlinebuf":"void", +"fprintf":"int", +"printf":"int", +"sprintf":"int", +"vfprintf":"int", +"vprintf":"int", +"vsprintf":"int", +"snprintf":"int", +"vsnprintf":"int", +"vasprintf":"int", +"__asprintf":"int", +"asprintf":"int", +"vdprintf":"int", +"dprintf":"int", +"fscanf":[("int","(FILE *__restrict, const char *__restrict, ...)"),("int","(FILE *__restrict, const char *__restrict, ...)")], +"scanf":[("int","(const char *__restrict, ...)"),("int","(const char *__restrict, ...)")], +"sscanf":[("int","(const char *__restrict, const char *__restrict, ...)"),("int","(const char *__restrict, const char *__restrict, ...)")], +"vfscanf":[("int","(FILE *__restrict, const char *__restrict, __va_list_tag *)"),("int","(FILE *__restrict, const char *__restrict, __va_list_tag *)")], +"vscanf":[("int","(const char *__restrict, __va_list_tag *)"),("int","(const char *__restrict, __va_list_tag *)")], +"vsscanf":[("int","(const char *__restrict, const char *__restrict, __va_list_tag *)"),("int","(const char *__restrict, const char *__restrict, __va_list_tag *)")], +"fgetc":"int", +"getc":"int", +"getchar":"int", +"getc_unlocked":"int", +"getchar_unlocked":"int", +"fgetc_unlocked":"int", +"fputc":"int", +"putc":"int", +"putchar":"int", +"fputc_unlocked":"int", +"putc_unlocked":"int", +"putchar_unlocked":"int", +"getw":"int", +"putw":"int", +"fgets":"char *", +"fgets_unlocked":"char *", +"__getdelim":"__ssize_t", +"getdelim":"__ssize_t", +"getline":[("__ssize_t","(char **__restrict, size_t *__restrict, FILE *__restrict)"),("basic_istream &","(basic_istream &, basic_string &, char)"),("basic_istream &","(basic_istream &, basic_string &, wchar_t)")], +"fputs":"int", +"puts":"int", +"ungetc":"int", +"fread":"size_t", +"fwrite":"size_t", +"fputs_unlocked":"int", +"fread_unlocked":"size_t", +"fwrite_unlocked":"size_t", +"fseek":"int", +"ftell":"long", +"rewind":"void", +"fseeko":"int", +"ftello":"__off_t", +"fgetpos":"int", +"fsetpos":"int", +"fseeko64":"int", +"ftello64":"__off64_t", +"fgetpos64":"int", +"fsetpos64":"int", +"clearerr":"void", +"feof":"int", +"ferror":"int", +"clearerr_unlocked":"void", +"feof_unlocked":"int", +"ferror_unlocked":"int", +"perror":"void", +"fileno":"int", +"fileno_unlocked":"int", +"pclose":"int", +"popen":"FILE *", +"ctermid":"char *", +"cuserid":"char *", +"obstack_printf":"int", +"obstack_vprintf":"int", +"flockfile":"void", +"ftrylockfile":"int", +"funlockfile":"void", +"__uflow":"int", +"__overflow":"int", +"memcpy":"void *", +"memmove":"void *", +"memccpy":"void *", +"memset":"void *", +"memcmp":"int", +"__memcmpeq":"int", +"memchr":[("void *","(void *, int, size_t)"),("const void *","(const void *, int, size_t)")], +"rawmemchr":[("void *","(void *, int)"),("const void *","(const void *, int)")], +"memrchr":[("void *","(void *, int, size_t)"),("const void *","(const void *, int, size_t)")], +"strcpy":"char *", +"strncpy":"char *", +"strcat":"char *", +"strncat":"char *", +"strcmp":"int", +"strncmp":"int", +"strcoll":"int", +"strxfrm":"size_t", +"strcoll_l":"int", +"strxfrm_l":"size_t", +"strdup":"char *", +"strndup":"char *", +"strchr":[("char *","(char *, int)"),("const char *","(const char *, int)")], +"strrchr":[("char *","(char *, int)"),("const char *","(const char *, int)")], +"strchrnul":[("char *","(char *, int)"),("const char *","(const char *, int)")], +"strcspn":"size_t", +"strspn":"size_t", +"strpbrk":[("char *","(char *, const char *)"),("const char *","(const char *, const char *)")], +"strstr":[("char *","(char *, const char *)"),("const char *","(const char *, const char *)")], +"strtok":"char *", +"__strtok_r":"char *", +"strtok_r":"char *", +"strcasestr":[("char *","(char *, const char *)"),("const char *","(const char *, const char *)")], +"memmem":"void *", +"__mempcpy":"void *", +"mempcpy":"void *", +"strlen":"size_t", +"strnlen":"size_t", +"strerror":"char *", +"strerror_r":"char *", +"strerrordesc_np":"const char *", +"strerrorname_np":"const char *", +"strerror_l":"char *", +"bcmp":"int", +"bcopy":"void", +"bzero":"void", +"index":"char *", +"rindex":"char *", +"ffs":"int", +"ffsl":"int", +"ffsll":"int", +"strcasecmp":"int", +"strncasecmp":"int", +"strcasecmp_l":"int", +"strncasecmp_l":"int", +"explicit_bzero":"void", +"strsep":"char *", +"strsignal":"char *", +"sigabbrev_np":"const char *", +"sigdescr_np":"const char *", +"__stpcpy":"char *", +"stpcpy":"char *", +"__stpncpy":"char *", +"stpncpy":"char *", +"strverscmp":"int", +"strfry":"char *", +"memfrob":"void *", +"basename":[("char *","(char *)"),("const char *","(const char *)")], +"clock_adjtime":"int", +"clock":"clock_t", +"time":"time_t", +"difftime":"double", +"mktime":"time_t", +"strftime":"size_t", +"strptime":"char *", +"strftime_l":"size_t", +"strptime_l":"char *", +"gmtime":"struct tm *", +"localtime":"struct tm *", +"gmtime_r":"struct tm *", +"localtime_r":"struct tm *", +"asctime":"char *", +"ctime":"char *", +"asctime_r":"char *", +"ctime_r":"char *", +"tzset":"void", +"timegm":"time_t", +"timelocal":"time_t", +"dysize":"int", +"nanosleep":"int", +"clock_getres":"int", +"clock_gettime":"int", +"clock_settime":"int", +"clock_nanosleep":"int", +"clock_getcpuclockid":"int", +"timer_create":"int", +"timer_delete":"int", +"timer_settime":"int", +"timer_gettime":"int", +"timer_getoverrun":"int", +"timespec_get":"int", +"timespec_getres":"int", +"getdate":"struct tm *", +"getdate_r":"int", +"wcscpy":"wchar_t *", +"wcsncpy":"wchar_t *", +"wcscat":"wchar_t *", +"wcsncat":"wchar_t *", +"wcscmp":"int", +"wcsncmp":"int", +"wcscasecmp":"int", +"wcsncasecmp":"int", +"wcscasecmp_l":"int", +"wcsncasecmp_l":"int", +"wcscoll":"int", +"wcsxfrm":"size_t", +"wcscoll_l":"int", +"wcsxfrm_l":"size_t", +"wcsdup":"wchar_t *", +"wcschr":[("wchar_t *","(const wchar_t *, wchar_t)"),("wchar_t *","(wchar_t *, wchar_t)")], +"wcsrchr":[("wchar_t *","(const wchar_t *, wchar_t)"),("wchar_t *","(wchar_t *, wchar_t)")], +"wcschrnul":"wchar_t *", +"wcscspn":"size_t", +"wcsspn":"size_t", +"wcspbrk":[("wchar_t *","(const wchar_t *, const wchar_t *)"),("wchar_t *","(wchar_t *, const wchar_t *)")], +"wcsstr":[("wchar_t *","(const wchar_t *, const wchar_t *)"),("wchar_t *","(wchar_t *, const wchar_t *)")], +"wcstok":"wchar_t *", +"wcslen":"size_t", +"wcswcs":"wchar_t *", +"wcsnlen":"size_t", +"wmemchr":[("wchar_t *","(const wchar_t *, wchar_t, size_t)"),("wchar_t *","(wchar_t *, wchar_t, std::size_t)")], +"wmemcmp":"int", +"wmemcpy":"wchar_t *", +"wmemmove":"wchar_t *", +"wmemset":"wchar_t *", +"wmempcpy":"wchar_t *", +"btowc":"wint_t", +"wctob":"int", +"mbsinit":"int", +"mbrtowc":"size_t", +"wcrtomb":"size_t", +"__mbrlen":"size_t", +"mbrlen":"size_t", +"mbsrtowcs":"size_t", +"wcsrtombs":"size_t", +"mbsnrtowcs":"size_t", +"wcsnrtombs":"size_t", +"wcwidth":"int", +"wcswidth":"int", +"wcstod":"double", +"wcstof":"float", +"wcstold":"long double", +"wcstof32":"_Float32", +"wcstof64":"_Float64", +"wcstof32x":"_Float32x", +"wcstof64x":"_Float64x", +"wcstol":"long", +"wcstoul":"unsigned long", +"wcstoll":"long long", +"wcstoull":"unsigned long long", +"wcstoq":"long long", +"wcstouq":"unsigned long long", +"wcstol_l":"long", +"wcstoul_l":"unsigned long", +"wcstoll_l":"long long", +"wcstoull_l":"unsigned long long", +"wcstod_l":"double", +"wcstof_l":"float", +"wcstold_l":"long double", +"wcstof32_l":"_Float32", +"wcstof64_l":"_Float64", +"wcstof32x_l":"_Float32x", +"wcstof64x_l":"_Float64x", +"wcpcpy":"wchar_t *", +"wcpncpy":"wchar_t *", +"open_wmemstream":"__FILE *", +"fwide":"int", +"fwprintf":"int", +"wprintf":"int", +"swprintf":"int", +"vfwprintf":"int", +"vwprintf":"int", +"vswprintf":"int", +"fwscanf":[("int","(__FILE *__restrict, const wchar_t *__restrict, ...)"),("int","(__FILE *__restrict, const wchar_t *__restrict, ...)")], +"wscanf":[("int","(const wchar_t *__restrict, ...)"),("int","(const wchar_t *__restrict, ...)")], +"swscanf":[("int","(const wchar_t *__restrict, const wchar_t *__restrict, ...)"),("int","(const wchar_t *__restrict, const wchar_t *__restrict, ...)")], +"vfwscanf":[("int","(__FILE *__restrict, const wchar_t *__restrict, __va_list_tag *)"),("int","(__FILE *__restrict, const wchar_t *__restrict, __va_list_tag *)")], +"vwscanf":[("int","(const wchar_t *__restrict, __va_list_tag *)"),("int","(const wchar_t *__restrict, __va_list_tag *)")], +"vswscanf":[("int","(const wchar_t *__restrict, const wchar_t *__restrict, __va_list_tag *)"),("int","(const wchar_t *__restrict, const wchar_t *__restrict, __va_list_tag *)")], +"fgetwc":"wint_t", +"getwc":"wint_t", +"getwchar":"wint_t", +"fputwc":"wint_t", +"putwc":"wint_t", +"putwchar":"wint_t", +"fgetws":"wchar_t *", +"fputws":"int", +"ungetwc":"wint_t", +"getwc_unlocked":"wint_t", +"getwchar_unlocked":"wint_t", +"fgetwc_unlocked":"wint_t", +"fputwc_unlocked":"wint_t", +"putwc_unlocked":"wint_t", +"putwchar_unlocked":"wint_t", +"fgetws_unlocked":"wchar_t *", +"fputws_unlocked":"int", +"wcsftime":"size_t", +"wcsftime_l":"size_t", +"iswalnum":"int", +"iswalpha":"int", +"iswcntrl":"int", +"iswdigit":"int", +"iswgraph":"int", +"iswlower":"int", +"iswprint":"int", +"iswpunct":"int", +"iswspace":"int", +"iswupper":"int", +"iswxdigit":"int", +"iswblank":"int", +"wctype":"wctype_t", +"iswctype":"int", +"towlower":"wint_t", +"towupper":"wint_t", +"wctrans":"wctrans_t", +"towctrans":"wint_t", +"iswalnum_l":"int", +"iswalpha_l":"int", +"iswcntrl_l":"int", +"iswdigit_l":"int", +"iswgraph_l":"int", +"iswlower_l":"int", +"iswprint_l":"int", +"iswpunct_l":"int", +"iswspace_l":"int", +"iswupper_l":"int", +"iswxdigit_l":"int", +"iswblank_l":"int", +"wctype_l":"wctype_t", +"iswctype_l":"int", +"towlower_l":"wint_t", +"towupper_l":"wint_t", +"wctrans_l":"wctrans_t", +"towctrans_l":"wint_t", +"set_terminate":"std::terminate_handler", +"get_terminate":"std::terminate_handler", +"terminate":"void", +"set_unexpected":"std::unexpected_handler", +"get_unexpected":"std::unexpected_handler", +"unexpected":"void", +"uncaught_exception":"bool", +"uncaught_exceptions":"int", +"__verbose_terminate_handler":"void", +"__cxa_allocate_exception":"void *", +"__cxa_free_exception":"void", +"__cxa_init_primary_exception":"__cxxabiv1::__cxa_refcounted_exception *", +"_Hash_bytes":"std::size_t", +"_Fnv_hash_bytes":"std::size_t", +"set_new_handler":"std::new_handler", +"get_new_handler":"std::new_handler", +"current_exception":[("std::__exception_ptr::exception_ptr","()"),("std::__exception_ptr::exception_ptr","()")], +"rethrow_exception":[("void","(std::__exception_ptr::exception_ptr)"),("void","(std::__exception_ptr::exception_ptr)")], +"swap":[("void","(std::__exception_ptr::exception_ptr &, std::__exception_ptr::exception_ptr &)"),("void","(std::_Bit_reference, std::_Bit_reference)"),("void","(std::_Bit_reference, bool &)"),("void","(bool &, std::_Bit_reference)"),("void","(std::thread &, std::thread &)")], +"__rethrow_if_nested_impl":"void", +"__throw_bad_exception":"void", +"__throw_bad_alloc":"void", +"__throw_bad_array_new_length":"void", +"__throw_bad_cast":"void", +"__throw_bad_typeid":"void", +"__throw_logic_error":"void", +"__throw_domain_error":"void", +"__throw_invalid_argument":"void", +"__throw_length_error":"void", +"__throw_out_of_range":"void", +"__throw_out_of_range_fmt":"void", +"__throw_runtime_error":"void", +"__throw_range_error":"void", +"__throw_overflow_error":"void", +"__throw_underflow_error":"void", +"__throw_ios_failure":[("void","(const char *)"),("void","(const char *, int)")], +"__throw_system_error":"void", +"__throw_future_error":[("void","(int)"),("void","(int)")], +"__throw_bad_function_call":"void", +"__iter_less_iter":"__gnu_cxx::__ops::_Iter_less_iter", +"__iter_less_val":"__gnu_cxx::__ops::_Iter_less_val", +"__iter_comp_val":[("__gnu_cxx::__ops::_Iter_less_val","(__gnu_cxx::__ops::_Iter_less_iter)"),("__gnu_cxx::__ops::_Iter_equal_to_val","(__gnu_cxx::__ops::_Iter_equal_to_iter)")], +"__val_less_iter":"__gnu_cxx::__ops::_Val_less_iter", +"__val_comp_iter":"__gnu_cxx::__ops::_Val_less_iter", +"__iter_equal_to_iter":"__gnu_cxx::__ops::_Iter_equal_to_iter", +"__iter_equal_to_val":"__gnu_cxx::__ops::_Iter_equal_to_val", +"__fill_a1":[("void","(std::_Bit_iterator, std::_Bit_iterator, const bool &)"),("void","(std::_Bit_iterator, std::_Bit_iterator, const bool &)")], +"__size_to_integer":[("int","(int)"),("unsigned int","(unsigned int)"),("long","(long)"),("unsigned long","(unsigned long)"),("long long","(long long)"),("unsigned long long","(unsigned long long)"),("__int128","(__int128)"),("unsigned __int128","(unsigned __int128)"),("long long","(float)"),("long long","(double)"),("long long","(long double)"),("long long","(__float128)")], +"__lg":[("int","(int)"),("unsigned int","(unsigned int)"),("long","(long)"),("unsigned long","(unsigned long)"),("long long","(long long)"),("unsigned long long","(unsigned long long)")], +"__uselocale":"void *", +"__convert_from_v":"int", +"clone":"int", +"unshare":"int", +"sched_getcpu":"int", +"getcpu":"int", +"setns":"int", +"__sched_cpucount":"int", +"__sched_cpualloc":"cpu_set_t *", +"__sched_cpufree":"void", +"sched_setparam":"int", +"sched_getparam":"int", +"sched_setscheduler":"int", +"sched_getscheduler":"int", +"sched_yield":"int", +"sched_get_priority_max":"int", +"sched_get_priority_min":"int", +"sched_rr_get_interval":"int", +"sched_setaffinity":"int", +"sched_getaffinity":"int", +"pthread_create":"int", +"pthread_exit":"void", +"pthread_join":"int", +"pthread_tryjoin_np":"int", +"pthread_timedjoin_np":"int", +"pthread_clockjoin_np":"int", +"pthread_detach":"int", +"pthread_self":"pthread_t", +"pthread_equal":"int", +"pthread_attr_init":"int", +"pthread_attr_destroy":"int", +"pthread_attr_getdetachstate":"int", +"pthread_attr_setdetachstate":"int", +"pthread_attr_getguardsize":"int", +"pthread_attr_setguardsize":"int", +"pthread_attr_getschedparam":"int", +"pthread_attr_setschedparam":"int", +"pthread_attr_getschedpolicy":"int", +"pthread_attr_setschedpolicy":"int", +"pthread_attr_getinheritsched":"int", +"pthread_attr_setinheritsched":"int", +"pthread_attr_getscope":"int", +"pthread_attr_setscope":"int", +"pthread_attr_getstackaddr":"int", +"pthread_attr_setstackaddr":"int", +"pthread_attr_getstacksize":"int", +"pthread_attr_setstacksize":"int", +"pthread_attr_getstack":"int", +"pthread_attr_setstack":"int", +"pthread_attr_setaffinity_np":"int", +"pthread_attr_getaffinity_np":"int", +"pthread_getattr_default_np":"int", +"pthread_attr_setsigmask_np":"int", +"pthread_attr_getsigmask_np":"int", +"pthread_setattr_default_np":"int", +"pthread_getattr_np":"int", +"pthread_setschedparam":"int", +"pthread_getschedparam":"int", +"pthread_setschedprio":"int", +"pthread_getname_np":"int", +"pthread_setname_np":"int", +"pthread_getconcurrency":"int", +"pthread_setconcurrency":"int", +"pthread_yield":[("int","()"),("int","()")], +"pthread_setaffinity_np":"int", +"pthread_getaffinity_np":"int", +"pthread_once":"int", +"pthread_setcancelstate":"int", +"pthread_setcanceltype":"int", +"pthread_cancel":"int", +"pthread_testcancel":"void", +"pthread_mutex_init":"int", +"pthread_mutex_destroy":"int", +"pthread_mutex_trylock":"int", +"pthread_mutex_lock":"int", +"pthread_mutex_timedlock":"int", +"pthread_mutex_clocklock":"int", +"pthread_mutex_unlock":"int", +"pthread_mutex_getprioceiling":"int", +"pthread_mutex_setprioceiling":"int", +"pthread_mutex_consistent":"int", +"pthread_mutex_consistent_np":"int", +"pthread_mutexattr_init":"int", +"pthread_mutexattr_destroy":"int", +"pthread_mutexattr_getpshared":"int", +"pthread_mutexattr_setpshared":"int", +"pthread_mutexattr_gettype":"int", +"pthread_mutexattr_settype":"int", +"pthread_mutexattr_getprotocol":"int", +"pthread_mutexattr_setprotocol":"int", +"pthread_mutexattr_getprioceiling":"int", +"pthread_mutexattr_setprioceiling":"int", +"pthread_mutexattr_getrobust":"int", +"pthread_mutexattr_getrobust_np":"int", +"pthread_mutexattr_setrobust":"int", +"pthread_mutexattr_setrobust_np":"int", +"pthread_rwlock_init":"int", +"pthread_rwlock_destroy":"int", +"pthread_rwlock_rdlock":"int", +"pthread_rwlock_tryrdlock":"int", +"pthread_rwlock_timedrdlock":"int", +"pthread_rwlock_clockrdlock":"int", +"pthread_rwlock_wrlock":"int", +"pthread_rwlock_trywrlock":"int", +"pthread_rwlock_timedwrlock":"int", +"pthread_rwlock_clockwrlock":"int", +"pthread_rwlock_unlock":"int", +"pthread_rwlockattr_init":"int", +"pthread_rwlockattr_destroy":"int", +"pthread_rwlockattr_getpshared":"int", +"pthread_rwlockattr_setpshared":"int", +"pthread_rwlockattr_getkind_np":"int", +"pthread_rwlockattr_setkind_np":"int", +"pthread_cond_init":"int", +"pthread_cond_destroy":"int", +"pthread_cond_signal":"int", +"pthread_cond_broadcast":"int", +"pthread_cond_wait":"int", +"pthread_cond_timedwait":"int", +"pthread_cond_clockwait":"int", +"pthread_condattr_init":"int", +"pthread_condattr_destroy":"int", +"pthread_condattr_getpshared":"int", +"pthread_condattr_setpshared":"int", +"pthread_condattr_getclock":"int", +"pthread_condattr_setclock":"int", +"pthread_spin_init":"int", +"pthread_spin_destroy":"int", +"pthread_spin_lock":"int", +"pthread_spin_trylock":"int", +"pthread_spin_unlock":"int", +"pthread_barrier_init":"int", +"pthread_barrier_destroy":"int", +"pthread_barrier_wait":"int", +"pthread_barrierattr_init":"int", +"pthread_barrierattr_destroy":"int", +"pthread_barrierattr_getpshared":"int", +"pthread_barrierattr_setpshared":"int", +"pthread_key_create":"int", +"pthread_key_delete":"int", +"pthread_getspecific":"void *", +"pthread_setspecific":"int", +"pthread_getcpuclockid":"int", +"pthread_atfork":"int", +"__gthread_active_p":"int", +"__gthread_create":"int", +"__gthread_join":"int", +"__gthread_detach":"int", +"__gthread_equal":"int", +"__gthread_self":"__gthread_t", +"__gthread_yield":"int", +"__gthread_once":"int", +"__gthread_key_create":"int", +"__gthread_key_delete":"int", +"__gthread_getspecific":"void *", +"__gthread_setspecific":"int", +"__gthread_mutex_init_function":"void", +"__gthread_mutex_destroy":"int", +"__gthread_mutex_lock":"int", +"__gthread_mutex_trylock":"int", +"__gthread_mutex_timedlock":"int", +"__gthread_mutex_unlock":"int", +"__gthread_recursive_mutex_lock":"int", +"__gthread_recursive_mutex_trylock":"int", +"__gthread_recursive_mutex_timedlock":"int", +"__gthread_recursive_mutex_unlock":"int", +"__gthread_recursive_mutex_destroy":"int", +"__gthread_cond_broadcast":"int", +"__gthread_cond_signal":"int", +"__gthread_cond_wait":"int", +"__gthread_cond_timedwait":"int", +"__gthread_cond_wait_recursive":"int", +"__gthread_cond_destroy":"int", +"__is_single_threaded":"bool", +"__exchange_and_add":"_Atomic_word", +"__atomic_add":"void", +"__exchange_and_add_single":"_Atomic_word", +"__atomic_add_single":"void", +"__exchange_and_add_dispatch":"_Atomic_word", +"__atomic_add_dispatch":"void", +"stoi":[("int","(const std::string &, std::size_t *, int)"),("int","(const std::wstring &, std::size_t *, int)")], +"stol":[("long","(const std::string &, std::size_t *, int)"),("long","(const std::wstring &, std::size_t *, int)")], +"stoul":[("unsigned long","(const std::string &, std::size_t *, int)"),("unsigned long","(const std::wstring &, std::size_t *, int)")], +"stoll":[("long long","(const std::string &, std::size_t *, int)"),("long long","(const std::wstring &, std::size_t *, int)")], +"stoull":[("unsigned long long","(const std::string &, std::size_t *, int)"),("unsigned long long","(const std::wstring &, std::size_t *, int)")], +"stof":[("float","(const std::string &, std::size_t *)"),("float","(const std::wstring &, std::size_t *)")], +"stod":[("double","(const std::string &, std::size_t *)"),("double","(const std::wstring &, std::size_t *)")], +"stold":[("long double","(const std::string &, std::size_t *)"),("long double","(const std::wstring &, std::size_t *)")], +"to_string":[("std::string","(int)"),("std::string","(unsigned int)"),("std::string","(long)"),("std::string","(unsigned long)"),("std::string","(long long)"),("std::string","(unsigned long long)"),("std::string","(float)"),("std::string","(double)"),("std::string","(long double)")], +"to_wstring":[("std::wstring","(int)"),("std::wstring","(unsigned int)"),("std::wstring","(long)"),("std::wstring","(unsigned long)"),("std::wstring","(long long)"),("std::wstring","(unsigned long long)"),("std::wstring","(float)"),("std::wstring","(double)"),("std::wstring","(long double)")], +"generic_category":"const std::_V2::error_category &", +"system_category":"const std::_V2::error_category &", +"make_error_code":[("std::error_code","(std::errc)"),("std::error_code","(std::errc)"),("std::error_code","(std::io_errc)"),("std::error_code","(std::future_errc)")], +"make_error_condition":[("std::error_condition","(std::errc)"),("std::error_condition","(std::errc)"),("std::error_condition","(std::io_errc)"),("std::error_condition","(std::future_errc)")], +"iostream_category":"const std::_V2::error_category &", +"boolalpha":"std::ios_base &", +"noboolalpha":"std::ios_base &", +"showbase":"std::ios_base &", +"noshowbase":"std::ios_base &", +"showpoint":"std::ios_base &", +"noshowpoint":"std::ios_base &", +"showpos":"std::ios_base &", +"noshowpos":"std::ios_base &", +"skipws":"std::ios_base &", +"noskipws":"std::ios_base &", +"uppercase":"std::ios_base &", +"nouppercase":"std::ios_base &", +"unitbuf":"std::ios_base &", +"nounitbuf":"std::ios_base &", +"internal":"std::ios_base &", +"left":"std::ios_base &", +"right":"std::ios_base &", +"dec":"std::ios_base &", +"hex":"std::ios_base &", +"oct":"std::ios_base &", +"fixed":"std::ios_base &", +"scientific":"std::ios_base &", +"hexfloat":"std::ios_base &", +"defaultfloat":"std::ios_base &", +"__copy_streambufs_eof":[("std::streamsize","(basic_streambuf<_CharT, _Traits> *, basic_streambuf<_CharT, _Traits> *, bool &)"),("std::streamsize","(basic_streambuf *, basic_streambuf *, bool &)"),("std::streamsize","(basic_streambuf *, basic_streambuf *, bool &)")], +"__istream_extract":[("void","(std::istream &, char *, std::streamsize)"),("void","(std::istream &, char *, std::streamsize)")], +"__convert_to_v":[("void","(const char *, float &, ios_base::iostate &, const std::__c_locale &)"),("void","(const char *, double &, ios_base::iostate &, const std::__c_locale &)"),("void","(const char *, long double &, ios_base::iostate &, const std::__c_locale &)")], +"__verify_grouping":"bool", +"__complex_abs":[("void *",""),("void *",""),("void *","")], +"__complex_arg":[("void *",""),("void *",""),("void *","")], +"__complex_cos":[("void *",""),("void *",""),("void *","")], +"__complex_cosh":[("void *",""),("void *",""),("void *","")], +"__complex_exp":[("void *",""),("void *",""),("void *","")], +"__complex_log":[("void *",""),("void *",""),("void *","")], +"__complex_sin":[("void *",""),("void *",""),("void *","")], +"__complex_sinh":[("void *",""),("void *",""),("void *","")], +"__complex_sqrt":[("void *",""),("void *",""),("void *","")], +"__complex_tan":[("void *",""),("void *",""),("void *","")], +"__complex_tanh":[("void *",""),("void *",""),("void *","")], +"__complex_pow":[("void *",""),("void *",""),("void *","")], +"__complex_acos":[("void *",""),("void *",""),("void *","")], +"__complex_asin":[("void *",""),("void *",""),("void *","")], +"__complex_atan":[("void *",""),("void *",""),("void *","")], +"__complex_acosh":[("void *",""),("void *",""),("void *","")], +"__complex_asinh":[("void *",""),("void *",""),("void *","")], +"__complex_atanh":[("void *",""),("void *",""),("void *","")], +"__complex_proj":[("complex","(const complex &)"),("complex","(const complex &)"),("complex","(const complex &)")], +"feclearexcept":"int", +"fegetexceptflag":"int", +"feraiseexcept":"int", +"fesetexcept":"int", +"fesetexceptflag":"int", +"fetestexcept":"int", +"fetestexceptflag":"int", +"fegetround":"int", +"fesetround":"int", +"fegetenv":"int", +"feholdexcept":"int", +"fesetenv":"int", +"feupdateenv":"int", +"fegetmode":"int", +"fesetmode":"int", +"feenableexcept":"int", +"fedisableexcept":"int", +"fegetexcept":"int", +"imaxabs":"intmax_t", +"imaxdiv":"imaxdiv_t", +"strtoimax":"intmax_t", +"strtoumax":"uintmax_t", +"wcstoimax":"intmax_t", +"wcstoumax":"uintmax_t", +"mbrtoc16":"size_t", +"c16rtomb":"size_t", +"mbrtoc32":"size_t", +"c32rtomb":"size_t", +"__deque_buf_size":"std::size_t", +"gettext":"char *", +"dgettext":"char *", +"__dgettext":"char *", +"dcgettext":"char *", +"__dcgettext":"char *", +"ngettext":"char *", +"dngettext":"char *", +"dcngettext":"char *", +"textdomain":"char *", +"bindtextdomain":"char *", +"bind_textdomain_codeset":"char *", +"resetiosflags":"std::_Resetiosflags", +"setiosflags":"std::_Setiosflags", +"setbase":"std::_Setbase", +"setprecision":"std::_Setprecision", +"setw":"std::_Setw", +"_Rb_tree_increment":[("std::_Rb_tree_node_base *","(std::_Rb_tree_node_base *)"),("const std::_Rb_tree_node_base *","(const std::_Rb_tree_node_base *)")], +"_Rb_tree_decrement":[("std::_Rb_tree_node_base *","(std::_Rb_tree_node_base *)"),("const std::_Rb_tree_node_base *","(const std::_Rb_tree_node_base *)")], +"_Rb_tree_insert_and_rebalance":"void", +"_Rb_tree_rebalance_for_erase":"std::_Rb_tree_node_base *", +"_Rb_tree_black_count":"unsigned int", +"align":"void *", +"__throw_concurrence_lock_error":"void", +"__throw_concurrence_unlock_error":"void", +"__throw_concurrence_broadcast_error":"void", +"__throw_concurrence_wait_error":"void", +"__throw_bad_weak_ptr":"void", +"__enable_shared_from_this_base":[("const __enable_shared_from_this<_Tp, _Lp> *","(const __shared_count<_Lp> &, const __enable_shared_from_this<_Tp, _Lp> *)"),("const enable_shared_from_this<_Tp> *","(const __shared_count<> &, const enable_shared_from_this<_Tp> *)")], +"__cmpexch_failure_order2":"std::memory_order", +"__cmpexch_failure_order":"std::memory_order", +"atomic_thread_fence":"void", +"atomic_signal_fence":"void", +"declare_reachable":"void", +"declare_no_pointers":"void", +"undeclare_no_pointers":"void", +"get_pointer_safety":"std::pointer_safety", +"__fill_bvector":"void", +"__valarray_release_memory":"void", +"atomic_flag_test_and_set_explicit":[("bool","(std::atomic_flag *, std::memory_order)"),("bool","(volatile std::atomic_flag *, std::memory_order)")], +"atomic_flag_clear_explicit":[("void","(std::atomic_flag *, std::memory_order)"),("void","(volatile std::atomic_flag *, std::memory_order)")], +"atomic_flag_test_and_set":[("bool","(std::atomic_flag *)"),("bool","(volatile std::atomic_flag *)")], +"atomic_flag_clear":[("void","(std::atomic_flag *)"),("void","(volatile std::atomic_flag *)")], +"notify_all_at_thread_exit":"void", +"__once_proxy":"void", +"get_id":"thread::id", +"yield":"void", +"future_category":"const std::_V2::error_category &", +"__throw_regex_error":[("void","(regex_constants::error_type, const char *)"),("void","(regex_constants::error_type)"),("void","(regex_constants::error_type, const char *)")], +"__clp2":"std::size_t", +"__glibcxx_rwlock_rdlock":"int", +"__glibcxx_rwlock_tryrdlock":"int", +"__glibcxx_rwlock_wrlock":"int", +"__glibcxx_rwlock_trywrlock":"int", +"__glibcxx_rwlock_unlock":"int", +"__glibcxx_rwlock_timedrdlock":"int", +"__glibcxx_rwlock_timedwrlock":"int", + + } + diff --git a/tools/ExternalFunctionAuto-Completion/dict/libc.h b/tools/ExternalFunctionAuto-Completion/dict/libc.h new file mode 100644 index 000000000..4ed5684f3 --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/dict/libc.h @@ -0,0 +1,30 @@ +//this file include the header lib of c program +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include \ No newline at end of file diff --git a/tools/ExternalFunctionAuto-Completion/dict/libcxx.h b/tools/ExternalFunctionAuto-Completion/dict/libcxx.h new file mode 100644 index 000000000..165a4020e --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/dict/libcxx.h @@ -0,0 +1,2 @@ +//this file include the header lib of c program +#include \ No newline at end of file diff --git a/tools/ExternalFunctionAuto-Completion/framework.png b/tools/ExternalFunctionAuto-Completion/framework.png new file mode 100644 index 000000000..70b2281f3 Binary files /dev/null and b/tools/ExternalFunctionAuto-Completion/framework.png differ diff --git a/tools/ExternalFunctionAuto-Completion/generate_glibc_dict.py b/tools/ExternalFunctionAuto-Completion/generate_glibc_dict.py new file mode 100644 index 000000000..adf37a124 --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/generate_glibc_dict.py @@ -0,0 +1,261 @@ +# Copyright (c) 2020 Trail of Bits, Inc. +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see . + +# this file is based on the https://github.com/lifting-bits/mcsema project +# mcsema/mcsema/OS/Linux/generate_abi_wrapper.py +# the original script have some bugs, and can't solve the Name Mangling problem. +# this scipt is part of the External Function auto-completion, it's goal is to loop +# over the AST tree of given head file, and generate a dict that can be used for the auto-completion +from encodings import utf_8 +import imp +import os +import re +from pickle import TRUE +import sys +import argparse +import logging +from collections import defaultdict + + + +cc_path = os.environ['CLANG_EXE'] +cclib_path = os.environ['CLANG_LIB'] +assert cc_path, "Please specify environment variable 'CLANG_EXE' with path to clang executable" + +try: + import ccsyspath + syspath = ccsyspath.system_include_paths(cc_path) + print(syspath) +except ImportError: + syspath = list() + + +SUPPORTED_ARCH = ["x86", "amd64"] + +SUPPORTED_LIBRARY_TYPE = ["c", "cpp"] + +ARCH_NAME = "" + +ABI_LIBRARY_TYPE = "" + +logging.basicConfig(filename="debug.log",level=logging.DEBUG) + +py_header1 = """ +class dict: + dictionary={ + +""" +py_end1 = """ + } + +""" + +#The list saves the parsed functions +FUNCDECL_LIST = defaultdict(list) + + +UNSUPPORTED_FUNC = ["__isoc99_fscanf", "__isoc99_scanf","__isoc99_sscanf","__isoc99_vfscanf","__isoc99_vscanf","__isoc99_vsscanf", +"__isoc99_fwscanf","__isoc99_wscanf","__isoc99_swscanf","__isoc99_vfwscanf","__isoc99_vswscanf", +"__xpg_strerror_r","__xpg_sigpause"] + +LOCAL_HEADERS = [] + +# Process the function types and remove the `__attribute__((...))` identifier +# from the function types +def process_function_types(type_string): + """ Pre-process the function types for the Funcdecl + """ + split_string = type_string.split(' ') + return ' '.join(str for str in split_string if '__attribute__' not in str) + +def get_function_pointer(type_string): + """ convert the function types to the pointer type + """ + return type_string[0:type_string.find('(')] + #return type_string[0:type_string.find('(')-1] + " (*)" + type_string[type_string.find('('):] + +def is_valid_type(type_string): + if "_Complex" in type_string or 'typeof' in type_string: + return False + else: + return True + +def is_blacklisted_func(func_name): + if 'operator' in func_name: + return True + return False + +def visit_func_decl(node): + """ Visit the function decl node and create a map of + function name with the mangled name + """ + try: + from clang.cindex import CursorKind, TypeKind,LinkageKind + + except ImportError: + return + #Here, traverse the nodes in the AST tree and find FUNCTION_DECL, which is the function node + if node.kind == CursorKind.FUNCTION_DECL: + func_name = node.spelling + node.result_type.spelling + mangled_name = node.spelling + parameters_obj=re.search('[(].*[)]',node.displayname) + parameters=parameters_obj.string[parameters_obj.regs[0][0]:parameters_obj.regs[0][1]] + + + if not is_blacklisted_func(mangled_name): + func_type = process_function_types(node.type.spelling) + if is_valid_type(func_type): + + key=mangled_name + FUNCDECL_LIST[key].append([mangled_name,node.result_type.spelling,parameters]) + else: + FUNCDECL_LIST[func_name].append([mangled_name, 'void *', node.location,func_name]) + + + #recursive deep traversal + for i in node.get_children(): + visit_func_decl(i) + + + +def write_cc_file(hfile, outfile): + """ Generate ABI library source for the c headers; + """ + + # generate the abi lib cc file + with open(outfile, "w") as s: + s.write(py_header1) + #The first layer of loops traverses FUNCDECL_LIST + for key in FUNCDECL_LIST.keys(): + type_values = FUNCDECL_LIST[key] + #The second layer of loop, get the function name + for type in type_values: + #type[0,1,2] points to [mangled_name, node.result_type.spelling, parameters] + s.write("\"{0}\":\"{1}\",\n".format(type[0],type[1])) + #Finish writing "(void *) cos" + + s.write(py_end1) + + print("Number of functions: {}".format(len(FUNCDECL_LIST))) + +def write_cxx_file(hfile, outfile): + """ Generate ABI library source for the cxx headers; + """ + + # generate the abi lib cc file + with open(outfile, "w") as s: + s.write(py_header1) + #The first layer of loops traverses FUNCDECL_LIST + for key in FUNCDECL_LIST.keys(): + type_values = FUNCDECL_LIST[key] + #The second layer of loop, get the function name + #some funcs may have mutiple returns, we use a list to store all the returns with it's params + if len(type_values)!=1: + num=1 + s.write("\"{0}\":[".format(key)) + for func in type_values: + #func[0,1,2] points to [mangled_name, node.result_type.spelling, parameters] + s.write("(\"{0}\",\"{1}\")".format(func[1],func[2])) + if num !=len(type_values): + s.write(",") + num=num+1 + s.write("],\n") + else: + for type in type_values: + #type[0,1,2] points to [mangled_name, node.result_type.spelling, parameters] + s.write("\"{0}\":\"{1}\",\n".format(type[0],type[1])) + + s.write(py_end1) + + print("Number of functions: {}".format(len(FUNCDECL_LIST))) + + + +def write_library_file(hfile, outfile): + """ Generate the library files """ + try: + import clang.cindex + from clang.cindex import Config + Config.get_filename(Config) + Config.set_library_file(cclib_path) + #Config.set_library_file("/usr/lib/llvm-11/lib/libclang-11.so.1") + cc_index = clang.cindex.Index.create() + Config.get_filename(Config) + libc_type = 'c++' if ABI_LIBRARY_TYPE == "cpp" else 'c' + #tu is the parsed AST tree + #Switch here to use c or c++ analysis + #The default is -m64 + tu = cc_index.parse(hfile, args=['-x', libc_type, '-m64']) + + + #else: + #print("Unsupported architecture") + + print(tu.diagnostics) + visit_func_decl(tu.cursor) + + except ImportErro: + libc_type = 'c++' if ABI_LIBRARY_TYPE == "cpp" else 'c' + pass + + if libc_type == 'c': + write_cc_file(hfile, outfile) + elif libc_type == 'c++': + write_cxx_file(hfile, outfile) + + + +def parse_headers(infile, outfile): + + write_library_file(infile, outfile) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + #parser.add_argument( + #'--arch', + #help='Name of the architecture.', + #required=True) + + parser.add_argument( + '--type', + help='ABI Library types c/c++.', + required=True) + + parser.add_argument( + "--input", + help="The input pre-processed header file", + required=True) + + parser.add_argument( + "--output", + help="The output file generated with the script", + required=True) + + args = parser.parse_args(args=sys.argv[1:]) + + #ARCH_NAME = args.arch + #if ARCH_NAME not in SUPPORTED_ARCH: + #logger.debug("Arch {} is not supported!".format(args.arch)) + + ABI_LIBRARY_TYPE = args.type + if ABI_LIBRARY_TYPE not in SUPPORTED_LIBRARY_TYPE: + logger.debug("Library type {} not supported!".format(args.type)) + + res = bytes(os.path.dirname(os.path.abspath(args.input)), 'utf-8') + syspath.append(res) + parse_headers(args.input, args.output) diff --git a/tools/ExternalFunctionAuto-Completion/test/X86/MotivatingExample b/tools/ExternalFunctionAuto-Completion/test/X86/MotivatingExample new file mode 100755 index 000000000..75896d4d0 Binary files /dev/null and b/tools/ExternalFunctionAuto-Completion/test/X86/MotivatingExample differ diff --git a/tools/ExternalFunctionAuto-Completion/test/X86/MotivatingExample.cpp b/tools/ExternalFunctionAuto-Completion/test/X86/MotivatingExample.cpp new file mode 100644 index 000000000..ac2854ec5 --- /dev/null +++ b/tools/ExternalFunctionAuto-Completion/test/X86/MotivatingExample.cpp @@ -0,0 +1,12 @@ +#include +#include +#include +#include +int main() +{ + std::cout<